From d1b75a1a277cbcf5e4e7730be1c24fa483ce66ee Mon Sep 17 00:00:00 2001 From: Colby Mchenry Date: Mon, 20 Jul 2026 19:55:48 -0500 Subject: [PATCH] =?UTF-8?q?feat(kernel):=20R7b=20Dart=20walker=20=E2=80=94?= =?UTF-8?q?=20dart=20module,=20vendored-grammar-C=20d4d8f3e=20+=20wasm=20b?= =?UTF-8?q?yte-copy=20vendor,=20dart=20default-routed=20(#1386)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit R7b batch 4 #4 — the FINAL R7b language (docs/design/dart-kernel-port-checklist.md is the authoritative quirk list). The fourth vendored-grammar-C language, with a twist: production dart resolved its wasm from tree-sitter-wasms, whose dart dependency is an UNPINNED github:UserNobody14/tree-sitter-dart — a routine dependency update would have silently changed dart's grammar. This PR byte-copies the shipping 0.1.13 artifact into src/extraction/wasm/ (VENDORED_WASM_LANGS += dart) and compiles the same-commit (d4d8f3e337d8) parser.c/scanner.c in the kernel — table identity proven by the kernel-grammar-parity row. crates.io tree-sitter-dart is the nielsenko fork (different lineage) — rejected. The center of gravity is THE SIBLING-BODY DOUBLE-WALK, reproduced bug-for-bug: dart attaches every function/method body as a NEXT SIBLING of its signature, and the TS walkers consume each body TWICE — once via resolveBody (attributed to the function/method) and once via the enclosing generic walk (attributed to the file/class). Duplicate local-function nodes with the SAME id under different parents, duplicated calls/instantiates refs, and file/class-attributed fn-ref twins all emit in the exact observed interleave (a dedicated fixture pins the duplicate-id rows; the bloc kind-census spot-check pins the counts). Also preserved (probe-pinned): the extractBareCall selector matrix (the first callTypes=[] language — cascades completely invisible, `?.` encodes like `.`, the `ConfigT.load()` calls+references double emission with no callee-of-call skip, capitalized-chain `Foo.create().run` re-encode, const-object callee names); the constructor hooks (unnamed ctor skipped, named ctors/factories renamed to the CTOR name with the class as returnType, `@override (T) m()` record-misparse rescued by class-name validation); operator methods minting `method ""`; static_final_declaration constants via the visitNode hook while instance fields mint NOTHING; the prefixed-return-type prefix bug (`other.OtherClass f()` → returnType `other`); enum `with` mixins silent vs `implements` working; anonymous extensions named after the ON type; deferred imports invisible; named-argument callbacks NOT fn-ref-captured (the Flutter `onPressed:` idiom — future accuracy PR, TS-side first); `async*`/`sync*` NOT async; value-refs with the LIVE dart sibling-body pull and the `$X`-vs-`${X}` interpolation asymmetry; dartdoc kept in all three comment forms with the annotation-broken chain. Gates: parity sweeps first-run 0-diff on shelf/bloc/flutter — 5,815 clean files byte-parity, deferrals 10/21/1341 ≈ the survey's 10/21/~1340 (both-arm grammar reality: empty object patterns — the sealed-class idiom — and unnamed `library;` dominate; --max-deferral 0.3); full-init dumps byte-identical ×3 (shelf 7,959 / bloc 40,026 / flutter 1,855,319 dump lines); bloc per-kind node census identical across arms (the double-walk duplicate rows survive the store identically); kernel-dart-parity suite (7 fixtures + in-memory CRLF variants + double-walk duplicate-id pin + generated-file skip pin + two defer pins); full suite 2,688 green ×2 with CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += dart (20 langs — R7b COMPLETE). Co-authored-by: Claude Fable 5 --- CHANGELOG.md | 3 +- .../fixtures/kernel-parity/TortureCtors.dart | 39 + .../kernel-parity/TortureDoubleWalk.dart | 82 + .../kernel-parity/TortureFnrefDart.dart | 26 + .../fixtures/kernel-parity/TortureMini.dart | 77 + .../fixtures/kernel-parity/TortureSigs.dart | 42 + .../kernel-parity/TortureVrefDart.dart | 61 + __tests__/fixtures/kernel-parity/torture.dart | 231 + __tests__/kernel-dart-parity.test.ts | 178 + __tests__/kernel-grammar-parity.test.ts | 2 +- codegraph-kernel/build.rs | 24 + codegraph-kernel/grammars/dart/LICENSE | 20 + codegraph-kernel/grammars/dart/parser.c | 199872 +++++++++++++++ codegraph-kernel/grammars/dart/scanner.c | 130 + .../grammars/dart/tree_sitter/alloc.h | 54 + .../grammars/dart/tree_sitter/array.h | 291 + .../grammars/dart/tree_sitter/parser.h | 286 + codegraph-kernel/src/dart.rs | 1547 + codegraph-kernel/src/langs.rs | 14 +- codegraph-kernel/src/lib.rs | 2 + docs/design/dart-kernel-port-checklist.md | 1082 + docs/design/rust-kernel-migration-plan.md | 2 +- scripts/kernel-parity.mjs | 3 +- src/extraction/grammars.ts | 8 + src/extraction/kernel/index.ts | 7 + src/extraction/wasm/tree-sitter-dart.wasm | Bin 0 -> 984666 bytes 26 files changed, 204077 insertions(+), 6 deletions(-) create mode 100644 __tests__/fixtures/kernel-parity/TortureCtors.dart create mode 100644 __tests__/fixtures/kernel-parity/TortureDoubleWalk.dart create mode 100644 __tests__/fixtures/kernel-parity/TortureFnrefDart.dart create mode 100644 __tests__/fixtures/kernel-parity/TortureMini.dart create mode 100644 __tests__/fixtures/kernel-parity/TortureSigs.dart create mode 100644 __tests__/fixtures/kernel-parity/TortureVrefDart.dart create mode 100644 __tests__/fixtures/kernel-parity/torture.dart create mode 100644 __tests__/kernel-dart-parity.test.ts create mode 100644 codegraph-kernel/grammars/dart/LICENSE create mode 100644 codegraph-kernel/grammars/dart/parser.c create mode 100644 codegraph-kernel/grammars/dart/scanner.c create mode 100644 codegraph-kernel/grammars/dart/tree_sitter/alloc.h create mode 100644 codegraph-kernel/grammars/dart/tree_sitter/array.h create mode 100644 codegraph-kernel/grammars/dart/tree_sitter/parser.h create mode 100644 codegraph-kernel/src/dart.rs create mode 100644 docs/design/dart-kernel-port-checklist.md create mode 100755 src/extraction/wasm/tree-sitter-dart.wasm diff --git a/CHANGELOG.md b/CHANGELOG.md index 3f2676a..3703284 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ### New Features -- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, Swift, Kotlin, Scala, R, Lua, and Luau projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, symfony-, swift-nio-, kotlinx.coroutines-, ggplot2-, Kong-, and Scala-3-compiler-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely. +- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, Swift, Kotlin, Scala, Dart, R, Lua, and Luau projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, symfony-, swift-nio-, kotlinx.coroutines-, ggplot2-, Kong-, Scala-3-compiler-, and Flutter-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely. - Reference resolution now runs in parallel on large projects. When a project has enough pending references to make it worthwhile (roughly 150k+, typical for big Java/Kotlin/Spring codebases), resolution fans out across worker threads while results are applied in the exact order the single-threaded path would have used — the graph comes out byte-for-byte identical, about twice as fast end-to-end on a 4,000-file Java project in our testing. Small projects keep the single-threaded path automatically (the fan-out costs more than it saves there). Set `CODEGRAPH_NO_PARALLEL_RESOLVE=1` to disable, or `CODEGRAPH_PARALLEL_RESOLVE_MIN=` to tune when it engages. - Indexing large projects got another sizeable speedup — about a quarter less wall-clock on the same 4,000-file Java project, with the graph still byte-for-byte identical. Two changes: the database no longer interleaves expensive checkpoint housekeeping into the middle of resolution on a fresh index (it's folded once at the end instead), and while one batch's results are being written out, the worker threads are already resolving the next batch instead of sitting idle. - The dynamic-dispatch analysis that runs at the end of indexing (callback, event, and framework wiring) now runs its passes in parallel on large projects, cutting that stage roughly in half there — and a pass that crashes now retries safely instead of failing the whole index, which also makes very large codebases that previously died in this stage more likely to index to completion. Graphs remain byte-for-byte identical. @@ -32,6 +32,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). - Ruby files also parse with an up-to-date grammar now (the previously bundled build dated from early 2024), which fixes a misparse of safe-navigation operator-method calls (`recv&.!= x`) that had recorded the wrong callee name. - PHP files also parse with an up-to-date grammar now (the previously bundled build dated from 2023): files using modern PHP features — enum constants, PHP 8.4 property hooks, parenthesis-free `new X()->method()` chaining — no longer hit parse errors or misparses that dropped or garbled their symbols, so codebases like Symfony and Laravel index substantially more accurately. - Swift files also parse with an up-to-date grammar now (the previously bundled build dated from 2023): swift-testing `#expect`, `#Preview`-style macros, the `package` access modifier, and typed `throws` no longer produce parse errors that dropped surrounding symbols — server-side Swift projects like Vapor see the biggest recovery. +- Dart's grammar is now bundled with CodeGraph itself instead of being resolved from a third-party package whose Dart build floated on an unpinned upstream reference — a routine dependency update can no longer silently change how Dart files parse. - Searching or exploring by field names now finds the code that defines them. A query made of object keys or API field names (`profileInfo isTrialEligible quotaInfo billingMethod`) used to return unrelated results while the defining files never appeared, because three retrieval steps each dropped multi-word camelCase terms: an internal case-comparison bug, a match step that only considered classes (never functions or methods), and exploration seeding that required exact symbol-name matches. All three are fixed — `codegraph_explore` with a bag of field names now surfaces the controllers and services that assemble those fields. (#1196) - `codegraph.json`'s `includeIgnored` works again for the "folder of repos" layout: when one `.gitignore` rule covers a parent directory (`/repos/`) holding several embedded git repositories, opting in the individual repos (`"includeIgnored": ["repos/a/"]` — the exact spelling `codegraph init`'s own hint suggests) previously matched nothing and indexed zero files, looping the same suggestion back at you. Both spellings now work — name the parent directory to opt in everything under it, or name individual repos to opt in just those — and the hint no longer re-suggests repos that are already configured. (#1295) - Method calls on literals (`", ".join(...)` in Python, `"x".split(...)` in JavaScript, and the like) no longer produce call edges to unrelated project functions that happen to share the builtin's name — a codebase with a function called `join`, `get`, or `update` could show phantom callers from every string-builtin use. Additionally, a function nested inside another function is now only matched as a call target from inside its container, since it isn't reachable from anywhere else. Blast-radius and affected-test results get cleaner on Python and JavaScript codebases especially. (#1230) diff --git a/__tests__/fixtures/kernel-parity/TortureCtors.dart b/__tests__/fixtures/kernel-parity/TortureCtors.dart new file mode 100644 index 0000000..f5889d8 --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureCtors.dart @@ -0,0 +1,39 @@ +/** Block dartdoc for blockDoc. */ +void blockDoc() {} + +/// Line doc kept. +// Plain comment also kept? +void mixedDoc() {} + +// Only plain. +void plainDoc() {} + +extension type Meters(double value) { + double get km => value / 1000; + void report() { + print(km); + } +} + +class Action { + @override + (int, String) reduce() => (1, 'a'); + void caller() { + this.own(); + super.parent(); + generic(5); + final t = reduce(); + } +} + +enum Flag { on, off } + +void flagUse(Flag f) { + final v = Flag.on; + switch (f) { + case Flag.off: + use(v); + default: + break; + } +} diff --git a/__tests__/fixtures/kernel-parity/TortureDoubleWalk.dart b/__tests__/fixtures/kernel-parity/TortureDoubleWalk.dart new file mode 100644 index 0000000..10e60a1 --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureDoubleWalk.dart @@ -0,0 +1,82 @@ +final topFinal = seedValue(); +const topConst = 42; +var topVar = 7; +int topTyped = 8; +final multiA = 1, multiB = 2; + +int seedValue() => 9; + +void hostFn() { + void localFn(int n) { + inner(n); + } + localFn(3); + int localWithNew() { + final w = new Holder(1); + return w.n; + } + localWithNew(); +} + +class Holder { + final int n; + final untypedInit = 5; + static var mutable = 3; + Holder(this.n); + Holder.other() : n = compute(); + void useNew() { + final h = new Holder(2); + void methodLocal() { + h.touch(); + } + methodLocal(); + } + int get computed => helperCall(); +} + +void takeConst() { + pad(const EdgeInsets.all(8.0)); + make(const Holder(3)); +} + +Future asyncFn() async => 1; +Stream genFn() async* { + yield 1; +} +Iterable syncGen() sync* { + yield 2; +} + +/// Doc for annotated. +@deprecated +void annotated() {} + +@Deprecated('use other') +class OldClass {} + +@pragma('vm:entry-point') +void pragged() {} + +class Cfg { + static const retries = 3; +} + +void reader() { + use(Cfg.retries); + final msg = 'retry $topConst times ${topFinal}'; + print(msg); +} + +void shadower() { + final topConst = 1; + use(topConst); +} + +void refTaker() { + register(seedValue); + obj.cb = seedValue; + final table = [seedValue, hostFn]; + final map = {'k': seedValue, 'j': notDefinedHere}; + reg2(cb: seedValue); + final alias = seedValue; +} diff --git a/__tests__/fixtures/kernel-parity/TortureFnrefDart.dart b/__tests__/fixtures/kernel-parity/TortureFnrefDart.dart new file mode 100644 index 0000000..c45112a --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureFnrefDart.dart @@ -0,0 +1,26 @@ +void assigned() {} +void listed() {} +void mapped() {} +void selfStore() {} +class H { + var cb; + void wire(dynamic selfStore) { + this.cb = assigned; + cb = selfStore; + } +} +final tableTop = [listed]; +final mapTop = {'k': mapped}; +void aliased() {} +final aliasTop = aliased; +class K { + static final aliasStatic = aliased; +} +void onlyNamed() {} +void otherFn() {} +void positional() {} +void taker() { + reg(cb: onlyNamed); + reg2(handler: otherFn, plain: 1); + reg3(positional); +} diff --git a/__tests__/fixtures/kernel-parity/TortureMini.dart b/__tests__/fixtures/kernel-parity/TortureMini.dart new file mode 100644 index 0000000..456cd7c --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureMini.dart @@ -0,0 +1,77 @@ +import 'dart:async'; +import 'package:foo/bar.dart' as bar show Baz hide Qux; +import 'pkg.dart' deferred as lazy; +export 'src/out.dart' show Pub; +part 'part1.dart'; + +/// Doc line one. +/// Doc line two. +void topFn(int a, String b) { + var local = 5; + int typed = 6; + final con = 7; + int uninit; + uninit = 8; + local = a; + helper(a); + obj.method(a); + Config.setting; + Config.load(); + w?.render(); + list..add(1)..add(2); + final w2 = Widget(1); + final w3 = new Widget(2); + const e = EdgeInsets.all(8.0); + Foo.create().run(); + lower().chain(); + print('sum ${a + compute()} $local'); +} + +// plain comment +int get topGetter => 42; +set topSetter(int v) {} + +class Widget extends Base with Mix1, Mix2 implements Draw, Paint { + static const int kMax = 10; + static final shared = Widget(0); + final int size; + int count = 0; + var loose; + late String name; + Widget(this.size); + Widget.named(this.size) { init(); } + factory Widget.create() => Widget(1); + Widget._() : size = 0; + @override + void render(Canvas c) { c.draw(); } + static Widget make() => Widget(3); + int get area => size * size; + set area(int v) { count = v; } + Future load() async { await fetch(); } + operator +(Widget o) => Widget(size + o.size); +} + +mixin Mix1 on Base { + void mixMethod() { helper(0); } +} + +extension WidgetExt on Widget { + void extMethod() { render(null); } +} + +enum Color { red, green, blue } + +enum Status with Mix1 implements Draw { + ok(200), + err(500); + final int code; + const Status(this.code); + bool get good => code < 400; + static Status parse(int c) => ok; +} + +typedef IntFn = int Function(int); +typedef void OldStyle(int x); + +abstract class Base {} +class Draw {} diff --git a/__tests__/fixtures/kernel-parity/TortureSigs.dart b/__tests__/fixtures/kernel-parity/TortureSigs.dart new file mode 100644 index 0000000..2022e0a --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureSigs.dart @@ -0,0 +1,42 @@ +library my.lib; + +part of 'other.dart'; + +void params({int? a, required Widget child, String note = 'x'}) {} +void optional([int b = 0, Widget? w]) {} +void fnTypedParam(void cb(int x), int Function(String) modern) {} +num numRet(num n) => n; +dynamic dynRet(dynamic d) => d; +Object objRet(Object o) => o; +double dblRet(double d) => d; + +external void externalFn(); + +class Redir { + Redir(); + Redir.a() : this(); + const factory Redir.b() = RedirImpl; +} + +void lambdas(List xs) { + xs.forEach((e) => use(e)); + final f = (int a) { + helper(a); + }; + f(1); + xs.map((e) => e * 2).toList(); +} + +void bodyTypes(Object x) { + if (x is Widget) { + use(x); + } + final y = x as Widget; + final list = []; + final map = {}; + throw StateError('bad'); +} + +@override +@protected +void doubleAnno() {} diff --git a/__tests__/fixtures/kernel-parity/TortureVrefDart.dart b/__tests__/fixtures/kernel-parity/TortureVrefDart.dart new file mode 100644 index 0000000..f2248da --- /dev/null +++ b/__tests__/fixtures/kernel-parity/TortureVrefDart.dart @@ -0,0 +1,61 @@ +import 'package:foo/util.dart' as util; + +const SHARED_MAX = 10; +const kLimit = 20; +final DERIVED = SHARED_MAX + 1; +const low = 30; + +class Table { + static const COL_LIMIT = 5; + static const plain = 6; + void reads() { + use(SHARED_MAX); + use(Table.COL_LIMIT); + log('cap $kLimit and ${SHARED_MAX}'); + } + void shadowed() { + final SHARED_MAX = 1; + use(SHARED_MAX); + } +} + +void freeReader() { + use(kLimit); +} + +void uninitShadow() { + int DERIVED; + DERIVED = 2; + use(DERIVED); +} + +void assignOnly() { + low = 5; +} + +void prefixedCalls() { + util.helper(1); + util.Config.load(); + Widget.named(2); +} + +/// Doc on classy. +class Classy {} + +/// Doc on num const? +const DOCED = 1; + +/// Doc on enum. +enum E2 { a } + +/// Doc broken. +@override +void afterAnno() {} + +/// Kept doc. +void unicodeNext() {} + +// π and émoji 🎯 in a comment +void afterUnicode(String s) { + emit('café ☕ done'); +} diff --git a/__tests__/fixtures/kernel-parity/torture.dart b/__tests__/fixtures/kernel-parity/torture.dart new file mode 100644 index 0000000..fa4f73b --- /dev/null +++ b/__tests__/fixtures/kernel-parity/torture.dart @@ -0,0 +1,231 @@ +/// File-level doc for torture (glued to import? no — imports precede nothing). +import 'dart:async'; +import 'package:torture/other.dart' as other show OtherClass; +export 'src/reexported.dart' hide Hidden; +part 'torture_part.dart'; + +/// Doc line one. +/// Doc line two. +void topLevel(int count, String label) { + helper(count); +} + +/** Block dartdoc kept. */ +int blockDoc() => 1; + +// Plain comment doc. +String plainDoc() => 'x'; + +/// Broken by annotation. +@deprecated +void annotated() {} + +@Deprecated('with args') +@pragma('vm:entry-point') +void doubleAnno() {} + +const SHARED_MAX = 10; +final DERIVED_VAL = SHARED_MAX + 1; +const lowercase_const = 1; +final typedTop = compute(); +var topVar = 5; +int topTyped = 6; +final multiA = 1, multiB = 2; + +int get topGetter => 7; +set topSetter(int v) {} + +Future asyncFn() async => 'a'; +Stream genStar() async* { + yield 1; +} +Iterable syncStar() sync* { + yield 2; +} + +num numback(num n) => n; +dynamic dyn(dynamic d) => d; +Object obj(Object o) => o; +List listRet(Map m) => []; +WidgetT? nullableRet() => null; +other.OtherClass prefixedRet() => other.OtherClass(); +T generic(T v) => v; + +external void externalFn(); + +void params({int? named, required WidgetT child, String note = 'x'}) {} +void optionals([int pos = 0, WidgetT? w]) {} +void fnTyped(void cb(int x), int Function(String) modern) {} + +void bodyShapes(List xs, Object o) { + var local = 1; + int typed = 2; + final con = 3; + int uninit; + uninit = 4; + local = uninit; + helper(local); + obj.method(local); + this_like.deep.call3(local); + ConfigT.load(); + ConfigT.setting; + w?.render(); + y2..add(1)..add(2); + final w1 = WidgetT(1); + final w2 = new WidgetT(2); + pad(const EdgeInsetsT.all(8.0)); + FactoryT.create().run(); + lower().chain(); + WidgetT.named(3).chainTail(); + xs.map((e) => e * 2).toList(); + xs.forEach((e) => use(e)); + final lam = (int a) { + helper(a); + }; + lam(5); + void localFn(int n) { + inner(n); + } + localFn(6); + if (o is WidgetT) { + use(o); + } + final cast = o as WidgetT; + final tl = []; + throw StateError('bad'); +} + +void interpolation(int count) { + log('count $count and ${SHARED_MAX} via ${refresh()}'); +} + +void refTaker() { + register(topLevel); + obj.cb = topLevel; + final table = [topLevel, blockDoc]; + final m = {'k': topLevel, 'x': undefinedName}; + reg2(cb: topLevel); + forward(topLevel: topLevel); + final alias = topLevel; +} + +/// Class doc. +@immutable +class WidgetT extends BaseT with MixA, MixB implements DrawT { + static const int K_MAX = 9; + static final sharedInst = WidgetT(0); + static var mutableStatic = 1; + final int size; + final untyped = 5; + int counter = 0; + late String title; + WidgetT(this.size); + WidgetT.named(this.size) { + init(); + } + WidgetT.bodilessNamed() : size = seed(); + factory WidgetT.create() => WidgetT(1); + const factory WidgetT.redir() = WidgetT2; + @override + void render(CanvasT c) { + c.draw(); + } + static WidgetT make() => WidgetT(3); + int get area => size * size; + set area(int v) { + counter = v; + } + bool get privado => _check(); + bool _check() => true; + Future load() async { + await fetch(); + } + WidgetT operator +(WidgetT o) => WidgetT(size + o.size); + void useLocalNew() { + final h = new HolderT(2); + use(h); + } + void readsConst() { + use(K_MAX); + } +} + +class WidgetT2 extends WidgetT { + WidgetT2() : super(0); + void _privateMethod() {} +} + +class BaseT {} + +class DrawT {} + +class OnlyMix with MixA {} + +abstract class AbstractT { + void mustImpl(WidgetT w); + int get abstractGetter; +} + +sealed class ShapeT {} + +class CircleT extends ShapeT {} + +mixin MixA on BaseT { + void mixMethod() { + helper(1); + } +} + +mixin MixB implements DrawT { + int get mixGetter => 2; +} + +extension WidgetTExt on WidgetT { + void extMethod() { + render(CanvasT()); + } + + int get extGetter => 4; +} + +extension on String { + void anonExt() {} +} + +enum ColorT { red, green, blue } + +/// Enum doc. +enum StatusT with MixB implements DrawT { + ok(200), + err(500); + + final int code; + const StatusT(this.code); + bool get good => code < 400; + static StatusT parse(int c) => ok; +} + +typedef IntFn = int Function(int); +typedef void LegacyCb(int x); +typedef MapAlias = Map; + +extension type MetersT(double value) { + double get km => value / 1000; +} + +void patternUser(Object o) { + final v = ColorT.red; + switch (o) { + case ColorT.blue: + use(v); + default: + break; + } + final (a, b) = (1, 2); + use(a); +} + +// π unicode: “smart quotes” précède — column check ☕ +void afterUnicode(String seance) { + emit('café ☕ done'); +} diff --git a/__tests__/kernel-dart-parity.test.ts b/__tests__/kernel-dart-parity.test.ts new file mode 100644 index 0000000..812f9f8 --- /dev/null +++ b/__tests__/kernel-dart-parity.test.ts @@ -0,0 +1,178 @@ +/** + * Kernel↔wasm Dart extraction parity (R7b batch 4 of the kernel migration — + * the final R7b language). + * + * Asserts the native walker (codegraph-kernel/src/dart.rs) produces the SAME + * ExtractionResult as the wasm TreeSitterExtractor — nodes, edges, and + * unresolved refs compared as canonicalized multisets — over the checked-in + * fixtures (torture.dart: the master inventory — imports incl. deferred + * invisibility, dartdoc in all three comment forms with the + * annotation-broken chain, stacked annotations in reverse order, the + * static_final_declaration constants hook, the full ctor set with the + * unnamed-ctor skip and named-ctor renaming, operator methods as + * ``, the extractBareCall matrix incl. cascade invisibility and + * `?.`-as-`.`, the `ConfigT.load()` calls+references double emission, + * extends/with/implements ref kinds, enum `with` silence, anonymous + * extensions named after the ON type, value-ref targets with the sibling + * body pull; TortureDoubleWalk.dart: THE SIBLING-BODY DOUBLE-WALK — the + * duplicate local-function nodes with the same id under different parents + * and the exact duplicated-ref interleave; TortureFnrefDart.dart: fn-ref + * capture channels incl. named-argument non-capture and the file/class + * twins; TortureMini/TortureSigs/TortureCtors/TortureVrefDart: signatures + * verbatim, prefixed-return-type prefix bug, const factories invisible, + * value-ref matrix with `$X` vs `${X}` asymmetry) and their CRLF variants + * (derived in-memory — #1329), plus defer and generated-file pins. + * + * The full-repo sweeps live in scripts/kernel-parity.mjs (shelf/bloc/flutter + * with --max-deferral 0.3); this suite keeps the invariant alive in + * `npm test`. Skips when no kernel binary is staged; CODEGRAPH_KERNEL_EXPECT=1 + * turns that into a failure. + */ + +import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest'; +import * as fs from 'fs'; +import * as path from 'path'; +import { extractFromSource } from '../src/extraction'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel'; +import type { ExtractionResult } from '../src/types'; + +const KERNEL_PATH = path.join( + __dirname, + '..', + 'codegraph-kernel', + 'prebuilds', + `${process.platform}-${process.arch}`, + 'codegraph-kernel.node' +); +const kernelBuilt = fs.existsSync(KERNEL_PATH); + +const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'kernel-parity'); + +function canon(result: ExtractionResult): { nodes: string[]; edges: string[]; refs: string[] } { + return { + nodes: result.nodes + .map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort())) + .sort(), + edges: result.edges.map((e) => JSON.stringify(e, Object.keys(e).sort())).sort(), + refs: result.unresolvedReferences + .map((r) => JSON.stringify(r, Object.keys(r).sort())) + .sort(), + }; +} + +const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const; +let savedEnv: Record; + +describe.skipIf(!kernelBuilt)('kernel Dart extraction parity', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['dart']); + }); + + beforeEach(() => { + savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]])); + resetKernelForTests(); + }); + + afterEach(() => { + for (const k of ENV_KEYS) { + if (savedEnv[k] === undefined) delete process.env[k]; + else process.env[k] = savedEnv[k]; + } + resetKernelForTests(); + }); + + function assertParity(filePath: string, source: string, minNodes = 2): ExtractionResult { + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + const viaKernel = tryKernelExtract(filePath, source, 'dart'); + expect(viaKernel, `kernel extraction failed for ${filePath}`).not.toBeNull(); + + process.env.CODEGRAPH_KERNEL = '0'; + const viaWasm = extractFromSource(filePath, source, 'dart'); + delete process.env.CODEGRAPH_KERNEL; + + const k = canon(viaKernel!); + const w = canon(viaWasm); + expect(k.nodes, `${filePath}: nodes`).toEqual(w.nodes); + expect(k.edges, `${filePath}: edges`).toEqual(w.edges); + expect(k.refs, `${filePath}: refs`).toEqual(w.refs); + expect(viaWasm.nodes.length).toBeGreaterThanOrEqual(minNodes); + return viaKernel!; + } + + const FIXTURES = [ + ['torture.dart', 30], + ['TortureDoubleWalk.dart', 5], + ['TortureFnrefDart.dart', 3], + ['TortureMini.dart', 5], + ['TortureSigs.dart', 4], + ['TortureCtors.dart', 3], + ['TortureVrefDart.dart', 4], + ] as const; + + for (const [file, minNodes] of FIXTURES) { + it(`${file}: parity`, () => { + const src = fs.readFileSync(path.join(FIXTURE_DIR, file), 'utf8'); + assertParity(`fixtures/${file}`, src, minNodes); + }); + + it(`${file}: CRLF parity`, () => { + const src = fs.readFileSync(path.join(FIXTURE_DIR, file), 'utf8'); + const crlf = src.replace(/(? { + const src = fs.readFileSync(path.join(FIXTURE_DIR, 'TortureDoubleWalk.dart'), 'utf8'); + const result = assertParity('fixtures/TortureDoubleWalk.dart', src, 5); + // Local functions are minted TWICE — same (kind,name,line) → the SAME id + // — once under the enclosing function, once under the file/class (the + // sibling-body revisit). A dedupe here would silently diverge. + const byId = new Map(); + for (const n of result.nodes) byId.set(n.id, (byId.get(n.id) ?? 0) + 1); + const dupes = [...byId.values()].filter((c) => c > 1); + expect(dupes.length).toBeGreaterThan(0); + }); + + it('generated files extract but skip fn-ref and value-ref flushes', () => { + const src = fs.readFileSync(path.join(FIXTURE_DIR, 'TortureVrefDart.dart'), 'utf8'); + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + const viaKernel = tryKernelExtract('lib/model.g.dart', src, 'dart'); + expect(viaKernel).not.toBeNull(); + process.env.CODEGRAPH_KERNEL = '0'; + const viaWasm = extractFromSource('lib/model.g.dart', src, 'dart'); + delete process.env.CODEGRAPH_KERNEL; + const k = canon(viaKernel!); + const w = canon(viaWasm); + expect(k.nodes).toEqual(w.nodes); + expect(k.edges).toEqual(w.edges); + expect(k.refs).toEqual(w.refs); + // The skips: no function_ref refs, no valueRef edges. + expect(viaKernel!.unresolvedReferences.some((r) => r.referenceKind === 'function_ref')).toBe( + false + ); + expect(viaKernel!.edges.some((e) => e.metadata?.valueRef === true)).toBe(false); + }); + + it('empty object patterns defer (the dominant dart-3 error class)', () => { + const broken = 'int f(Object x) => switch (x) { Init() => 1, _ => 0 };\n'; + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + expect(tryKernelExtract('lib/pat.dart', broken, 'dart')).toBeNull(); + process.env.CODEGRAPH_KERNEL = '0'; + const viaWasm = extractFromSource('lib/pat.dart', broken, 'dart'); + delete process.env.CODEGRAPH_KERNEL; + expect(viaWasm.nodes.some((n) => n.kind === 'file')).toBe(true); + }); + + it('unnamed `library;` defers', () => { + const broken = '/// Doc.\nlibrary;\n\nvoid f() {}\n'; + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + expect(tryKernelExtract('lib/lib.dart', broken, 'dart')).toBeNull(); + }); +}); diff --git a/__tests__/kernel-grammar-parity.test.ts b/__tests__/kernel-grammar-parity.test.ts index 6053a9d..c77aecc 100644 --- a/__tests__/kernel-grammar-parity.test.ts +++ b/__tests__/kernel-grammar-parity.test.ts @@ -36,7 +36,7 @@ const kernelBuilt = fs.existsSync(KERNEL_PATH); // Every kernel-capable language. `jsx` shares the javascript grammar on BOTH // paths (langs.rs mirrors WASM_GRAMMAR_FILES), so the distinct grammars are: -const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau', 'scala']; +const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau', 'scala', 'dart']; describe.skipIf(!kernelBuilt)('kernel↔wasm grammar parity', () => { beforeAll(async () => { diff --git a/codegraph-kernel/build.rs b/codegraph-kernel/build.rs index 4fc379e..5907067 100644 --- a/codegraph-kernel/build.rs +++ b/codegraph-kernel/build.rs @@ -60,4 +60,28 @@ fn main() { scala.flag_if_supported("-utf-8"); // msvc scala.compile("tree-sitter-scala"); println!("cargo:rerun-if-changed=grammars/scala"); + + // Dart grammar — vendored C (fourth vendored-grammar-C language): the + // production wasm is the tree-sitter-wasms 0.1.13 artifact, whose dart + // dependency is an UNPINNED github:UserNobody14/tree-sitter-dart — the + // vendored wasm byte-copy (src/extraction/wasm/) plus these same-commit + // sources kill that hazard. crates.io tree-sitter-dart is the nielsenko + // FORK (different lineage) — rejected. Sources are + // UserNobody14/tree-sitter-dart master@d4d8f3e337d8 (dart checklist + // §Grammar prep): + // parser.c 5a42b47abb4d494f125dbdee9138979248041689b1aa36355550fa3e28dcb8b8 + // scanner.c 07a7b7818b175e9460523e705dd88d20f7b5141bac95c593d4426e6d52284996 + // scanner.c is load-bearing: string-template char classes and /** */ doc + // comments are external tokens. + let mut dart = cc::Build::new(); + dart.include("grammars/dart"); + dart.file("grammars/dart/parser.c"); + dart.file("grammars/dart/scanner.c"); + dart.flag_if_supported("-Wno-unused-parameter"); + dart.flag_if_supported("-Wno-unused-but-set-variable"); + dart.flag_if_supported("-Wno-trigraphs"); + dart.flag_if_supported("-Wno-unused-function"); + dart.flag_if_supported("-utf-8"); // msvc + dart.compile("tree-sitter-dart"); + println!("cargo:rerun-if-changed=grammars/dart"); } diff --git a/codegraph-kernel/grammars/dart/LICENSE b/codegraph-kernel/grammars/dart/LICENSE new file mode 100644 index 0000000..9633f23 --- /dev/null +++ b/codegraph-kernel/grammars/dart/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2020-2023 UserNobody14 and others + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/codegraph-kernel/grammars/dart/parser.c b/codegraph-kernel/grammars/dart/parser.c new file mode 100644 index 0000000..00079f0 --- /dev/null +++ b/codegraph-kernel/grammars/dart/parser.c @@ -0,0 +1,199872 @@ +/* Automatically @generated by tree-sitter v0.25.10 */ + +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#define LANGUAGE_VERSION 15 +#define STATE_COUNT 3640 +#define LARGE_STATE_COUNT 494 +#define SYMBOL_COUNT 524 +#define ALIAS_COUNT 1 +#define TOKEN_COUNT 161 +#define EXTERNAL_TOKEN_COUNT 7 +#define FIELD_COUNT 22 +#define MAX_ALIAS_SEQUENCE_LENGTH 10 +#define MAX_RESERVED_WORD_SET_SIZE 0 +#define PRODUCTION_ID_COUNT 115 +#define SUPERTYPE_COUNT 2 + +enum ts_symbol_identifiers { + sym_identifier = 1, + anon_sym_POUND = 2, + sym_decimal_integer_literal = 3, + sym_hex_integer_literal = 4, + sym_decimal_floating_point_literal = 5, + anon_sym_true = 6, + anon_sym_false = 7, + anon_sym_DQUOTE = 8, + anon_sym_SQUOTE = 9, + anon_sym_DQUOTE_DQUOTE_DQUOTE = 10, + anon_sym_SQUOTE_SQUOTE_SQUOTE = 11, + anon_sym_r_DQUOTE = 12, + anon_sym_DOLLAR = 13, + anon_sym_r_SQUOTE = 14, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE = 15, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE = 16, + anon_sym_LBRACE = 17, + anon_sym_RBRACE = 18, + aux_sym__sub_string_test_token1 = 19, + sym__unused_escape_sequence = 20, + anon_sym_LBRACK = 21, + anon_sym_COMMA = 22, + anon_sym_RBRACK = 23, + anon_sym_COLON = 24, + anon_sym_null = 25, + anon_sym_LPAREN = 26, + anon_sym_RPAREN = 27, + anon_sym_throw = 28, + anon_sym_EQ = 29, + anon_sym_PLUS_EQ = 30, + anon_sym_DASH_EQ = 31, + anon_sym_STAR_EQ = 32, + anon_sym_SLASH_EQ = 33, + anon_sym_PERCENT_EQ = 34, + anon_sym_TILDE_SLASH_EQ = 35, + anon_sym_LT_LT_EQ = 36, + anon_sym_GT_GT_EQ = 37, + anon_sym_GT_GT_GT_EQ = 38, + anon_sym_AMP_EQ = 39, + anon_sym_CARET_EQ = 40, + anon_sym_PIPE_EQ = 41, + anon_sym_QMARK_QMARK_EQ = 42, + anon_sym_QMARK_QMARK = 43, + anon_sym_QMARK = 44, + sym_equality_operator = 45, + anon_sym_LT = 46, + anon_sym_GT = 47, + anon_sym_LT_EQ = 48, + anon_sym_GT_EQ = 49, + anon_sym_PIPE = 50, + anon_sym_CARET = 51, + anon_sym_AMP = 52, + anon_sym_LT_LT = 53, + anon_sym_GT_GT = 54, + anon_sym_GT_GT_GT = 55, + sym__additive_operator = 56, + anon_sym_STAR = 57, + anon_sym_SLASH = 58, + anon_sym_PERCENT = 59, + anon_sym_TILDE_SLASH = 60, + sym_increment_operator = 61, + anon_sym_DOT_DOT_DOT = 62, + sym_minus_operator = 63, + anon_sym_BANG = 64, + anon_sym_TILDE = 65, + anon_sym_await = 66, + anon_sym_is = 67, + anon_sym_as = 68, + anon_sym_DOT = 69, + anon_sym_DOT_DOT = 70, + anon_sym_QMARK_DOT_DOT = 71, + anon_sym_QMARK_DOT = 72, + anon_sym_SEMI = 73, + anon_sym_switch = 74, + anon_sym_EQ_GT = 75, + anon_sym_when = 76, + anon_sym_default = 77, + anon_sym_do = 78, + anon_sym_while = 79, + anon_sym_continue = 80, + anon_sym_yield = 81, + anon_sym_return = 82, + anon_sym_on = 83, + anon_sym_try = 84, + anon_sym_catch = 85, + anon_sym_finally = 86, + anon_sym_if = 87, + anon_sym_case = 88, + anon_sym_else = 89, + anon_sym_for = 90, + anon_sym_in = 91, + anon_sym_AT = 92, + anon_sym_part = 93, + anon_sym_EQ_EQ = 94, + anon_sym_show = 95, + anon_sym_hide = 96, + anon_sym_enum = 97, + anon_sym_final = 98, + anon_sym_inline = 99, + anon_sym_class = 100, + anon_sym_extension = 101, + anon_sym_type = 102, + anon_sym_extends = 103, + anon_sym_with = 104, + anon_sym_LBRACK_RBRACK = 105, + anon_sym_LBRACK_RBRACK_EQ = 106, + sym_void_type = 107, + anon_sym_var = 108, + anon_sym_async = 109, + anon_sym_async_STAR = 110, + anon_sym_sync_STAR = 111, + anon_sym_POUND_BANG = 112, + aux_sym_script_tag_token1 = 113, + anon_sym_LF = 114, + anon_sym_library = 115, + sym_break_builtin = 116, + sym_assert_builtin = 117, + sym_rethrow_builtin = 118, + sym_part_of_builtin = 119, + anon_sym_covariant = 120, + anon_sym_deferred = 121, + anon_sym_export = 122, + anon_sym_factory = 123, + anon_sym_Function = 124, + anon_sym_get = 125, + anon_sym_native = 126, + anon_sym_implements = 127, + anon_sym_import = 128, + anon_sym_interface = 129, + anon_sym_base = 130, + anon_sym_abstract = 131, + anon_sym_sealed = 132, + anon_sym_operator = 133, + anon_sym_mixin = 134, + anon_sym_required = 135, + anon_sym_set = 136, + anon_sym_static = 137, + anon_sym_typedef = 138, + anon_sym_new = 139, + anon_sym_AMP_AMP = 140, + anon_sym_PIPE_PIPE = 141, + sym_const_builtin = 142, + anon_sym_late = 143, + anon_sym_external = 144, + anon_sym_this = 145, + anon_sym_super = 146, + sym_identifier_dollar_escaped = 147, + anon_sym_SLASH_SLASH = 148, + aux_sym_comment_token1 = 149, + anon_sym_SLASH_STAR = 150, + aux_sym_comment_token2 = 151, + anon_sym_SLASH_SLASH_SLASH = 152, + aux_sym_documentation_comment_token1 = 153, + sym__template_chars_double = 154, + sym__template_chars_single = 155, + sym__template_chars_double_single = 156, + sym__template_chars_single_single = 157, + sym__template_chars_raw_slash = 158, + sym__block_comment = 159, + sym__documentation_block_comment = 160, + sym_program = 161, + sym__top_level_definition = 162, + sym__bool_literal = 163, + sym__numeric_literal = 164, + sym__literal = 165, + sym_symbol_literal = 166, + sym_true = 167, + sym_false = 168, + sym_string_literal = 169, + sym__string_literal_double_quotes = 170, + sym__string_literal_single_quotes = 171, + sym__string_literal_double_quotes_multiple = 172, + sym__string_literal_single_quotes_multiple = 173, + sym__raw_string_literal_double_quotes = 174, + sym__raw_string_literal_single_quotes = 175, + sym__raw_string_literal_double_quotes_multiple = 176, + sym__raw_string_literal_single_quotes_multiple = 177, + sym_template_substitution = 178, + sym__sub_string_test = 179, + sym_escape_sequence = 180, + sym_list_literal = 181, + sym_set_or_map_literal = 182, + sym_pair = 183, + sym__element = 184, + sym_null_literal = 185, + sym_record_literal = 186, + sym__record_literal_no_const = 187, + sym_record_field = 188, + sym__expression = 189, + sym__expression_without_cascade = 190, + sym__real_expression = 191, + sym_throw_expression = 192, + sym_throw_expression_without_cascade = 193, + sym_rethrow_expression = 194, + sym_assignment_expression = 195, + sym_assignment_expression_without_cascade = 196, + sym_assignable_expression = 197, + sym__assignable_selector_part = 198, + sym__assignment_operator = 199, + sym_lambda_expression = 200, + sym_function_expression = 201, + sym_if_null_expression = 202, + aux_sym__if_null_expression = 203, + sym_conditional_expression = 204, + sym_logical_or_expression = 205, + sym_logical_and_expression = 206, + sym_equality_expression = 207, + sym_type_cast_expression = 208, + sym_type_test_expression = 209, + sym_relational_expression = 210, + sym_relational_operator = 211, + sym_bitwise_or_expression = 212, + sym_bitwise_xor_expression = 213, + sym_bitwise_and_expression = 214, + sym_shift_expression = 215, + sym_additive_expression = 216, + sym_multiplicative_expression = 217, + sym_bitwise_operator = 218, + sym__bitwise_operator = 219, + sym_shift_operator = 220, + sym__shift_operator = 221, + sym_additive_operator = 222, + sym_multiplicative_operator = 223, + sym__multiplicative_operator = 224, + sym__unary_expression = 225, + sym_unary_expression = 226, + sym__postfix_expression = 227, + sym_postfix_expression = 228, + sym_postfix_operator = 229, + sym_spread_element = 230, + sym_selector = 231, + sym_prefix_operator = 232, + sym_negation_operator = 233, + sym__exclamation_operator = 234, + sym_tilde_operator = 235, + sym_await_expression = 236, + sym_type_test = 237, + sym_is_operator = 238, + sym_type_cast = 239, + sym_as_operator = 240, + sym_new_expression = 241, + sym__dot_identifier = 242, + sym_const_object_expression = 243, + sym__primary = 244, + sym_parenthesized_expression = 245, + sym_constructor_invocation = 246, + sym_constructor_tearoff = 247, + sym_arguments = 248, + sym__argument_list = 249, + sym__any_argument = 250, + sym_argument = 251, + sym_named_argument = 252, + sym_cascade_section = 253, + sym__cascade_subsection = 254, + sym__cascade_assignment_section = 255, + sym_index_selector = 256, + sym_cascade_selector = 257, + sym_argument_part = 258, + sym_unconditional_assignable_selector = 259, + sym_conditional_assignable_selector = 260, + sym__assignable_selector = 261, + sym_type_arguments = 262, + sym__statement = 263, + sym_local_function_declaration = 264, + sym_block = 265, + sym_expression_statement = 266, + sym_assert_statement = 267, + sym_assertion = 268, + sym_assertion_arguments = 269, + sym_switch_statement = 270, + sym_switch_expression = 271, + sym_switch_expression_case = 272, + sym__guarded_pattern = 273, + sym__pattern = 274, + sym__logical_or_pattern = 275, + sym__logical_and_pattern = 276, + sym__relational_pattern = 277, + sym__unary_pattern = 278, + sym__primary_pattern = 279, + sym_cast_pattern = 280, + sym_null_check_pattern = 281, + sym_null_assert_pattern = 282, + sym_constant_pattern = 283, + sym_variable_pattern = 284, + sym__parenthesized_pattern = 285, + sym_list_pattern = 286, + sym__list_pattern_element = 287, + sym_rest_pattern = 288, + sym_map_pattern = 289, + sym__map_pattern_entry = 290, + sym_record_pattern = 291, + sym__pattern_field = 292, + sym_object_pattern = 293, + sym_pattern_variable_declaration = 294, + sym__outer_pattern = 295, + sym_pattern_assignment = 296, + sym_switch_block = 297, + sym_switch_statement_case = 298, + sym_switch_statement_default = 299, + sym_do_statement = 300, + sym_break_statement = 301, + sym_continue_statement = 302, + sym_yield_statement = 303, + sym_yield_each_statement = 304, + sym_return_statement = 305, + sym_try_statement = 306, + sym__on_part = 307, + sym__try_head = 308, + sym_catch_clause = 309, + sym_catch_parameters = 310, + sym_finally_clause = 311, + sym_if_element = 312, + sym_if_statement = 313, + sym_while_statement = 314, + sym_for_statement = 315, + sym_for_loop_parts = 316, + sym__for_loop_parts = 317, + sym_for_element = 318, + sym_annotation = 319, + sym_import_or_export = 320, + sym_library_import = 321, + sym_library_export = 322, + sym_import_specification = 323, + sym_part_directive = 324, + sym_part_of_directive = 325, + sym_uri = 326, + sym_configurable_uri = 327, + sym_configuration_uri = 328, + sym_configuration_uri_condition = 329, + sym_uri_test = 330, + sym_combinator = 331, + sym__identifier_list = 332, + sym_enum_declaration = 333, + sym_enum_body = 334, + sym_enum_constant = 335, + sym_type_alias = 336, + sym__class_modifiers = 337, + sym__mixin_class_modifiers = 338, + sym_class_definition = 339, + sym_extension_declaration = 340, + sym_extension_type_declaration = 341, + sym_representation_declaration = 342, + sym__metadata = 343, + sym_type_parameters = 344, + sym_type_parameter = 345, + sym_type_bound = 346, + sym_superclass = 347, + sym_mixins = 348, + sym_mixin_application_class = 349, + sym_mixin_application = 350, + sym_mixin_declaration = 351, + sym_interfaces = 352, + sym_class_body = 353, + sym_extension_body = 354, + sym_getter_signature = 355, + sym_setter_signature = 356, + sym_method_signature = 357, + sym_declaration = 358, + sym_identifier_list = 359, + sym_initialized_identifier_list = 360, + sym_initialized_identifier = 361, + sym_static_final_declaration_list = 362, + sym_binary_operator = 363, + sym_operator_signature = 364, + sym_static_final_declaration = 365, + sym__external_and_static = 366, + sym__final_or_const = 367, + sym_initializers = 368, + sym_initializer_list_entry = 369, + sym_field_initializer = 370, + sym_factory_constructor_signature = 371, + sym_redirecting_factory_constructor_signature = 372, + sym_redirection = 373, + sym_constructor_signature = 374, + sym_constant_constructor_signature = 375, + sym_scoped_identifier = 376, + sym_initialized_variable_definition = 377, + sym__declared_identifier = 378, + sym__final_const_var_or_type = 379, + sym__type = 380, + sym__type_not_function = 381, + sym__type_not_void_not_function = 382, + sym_function_type = 383, + aux_sym__function_type_tails = 384, + sym__function_type_tail = 385, + sym_parameter_type_list = 386, + sym_normal_parameter_type = 387, + sym_optional_parameter_types = 388, + sym_optional_positional_parameter_types = 389, + sym_named_parameter_types = 390, + sym__named_parameter_type = 391, + sym__type_not_void = 392, + sym_record_type = 393, + sym_record_type_field = 394, + sym_record_type_named_field = 395, + sym__type_not_void_list = 396, + sym__type_name = 397, + sym__type_dot_identifier = 398, + sym_typed_identifier = 399, + sym_nullable_type = 400, + sym_nullable_selector = 401, + sym__var_or_type = 402, + sym__final_var_or_type = 403, + sym_inferred_type = 404, + sym_function_body = 405, + sym_function_expression_body = 406, + sym_function_signature = 407, + sym__formal_parameter_part = 408, + sym_formal_parameter_list = 409, + sym__strict_formal_parameter_list = 410, + sym__normal_formal_parameters = 411, + sym_optional_formal_parameters = 412, + sym__optional_postional_formal_parameters = 413, + sym__named_formal_parameters = 414, + sym_formal_parameter = 415, + sym__default_formal_parameter = 416, + sym__default_named_parameter = 417, + sym__normal_formal_parameter = 418, + sym__function_formal_parameter = 419, + sym__simple_formal_parameter = 420, + sym_super_formal_parameter = 421, + sym_constructor_param = 422, + sym_local_variable_declaration = 423, + sym_script_tag = 424, + sym_library_name = 425, + sym_dotted_identifier_list = 426, + sym__identifier_or_new = 427, + sym_qualified = 428, + sym__as = 429, + sym_case_builtin = 430, + sym__covariant = 431, + sym__deferred = 432, + sym__export = 433, + sym__external = 434, + sym__factory = 435, + sym__function_builtin_identifier = 436, + sym__get = 437, + sym__native = 438, + sym__implements = 439, + sym__import = 440, + sym_interface = 441, + sym_base = 442, + sym_abstract = 443, + sym_sealed = 444, + sym__operator = 445, + sym_mixin = 446, + sym__required = 447, + sym__set = 448, + sym__static = 449, + sym__typedef = 450, + sym__new_builtin = 451, + sym_logical_and_operator = 452, + sym_logical_or_operator = 453, + sym_final_builtin = 454, + sym__late_builtin = 455, + sym__external_builtin = 456, + sym_this = 457, + sym_super = 458, + sym_label = 459, + sym__semicolon = 460, + sym_comment = 461, + sym_documentation_comment = 462, + aux_sym_program_repeat1 = 463, + aux_sym_program_repeat2 = 464, + aux_sym_program_repeat3 = 465, + aux_sym_program_repeat4 = 466, + aux_sym_string_literal_repeat1 = 467, + aux_sym__string_literal_double_quotes_repeat1 = 468, + aux_sym__string_literal_single_quotes_repeat1 = 469, + aux_sym__string_literal_double_quotes_multiple_repeat1 = 470, + aux_sym__string_literal_single_quotes_multiple_repeat1 = 471, + aux_sym__raw_string_literal_double_quotes_repeat1 = 472, + aux_sym__raw_string_literal_single_quotes_repeat1 = 473, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1 = 474, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1 = 475, + aux_sym_list_literal_repeat1 = 476, + aux_sym__record_literal_no_const_repeat1 = 477, + aux_sym__expression_repeat1 = 478, + aux_sym__assignable_selector_part_repeat1 = 479, + aux_sym_logical_or_expression_repeat1 = 480, + aux_sym_logical_and_expression_repeat1 = 481, + aux_sym_bitwise_or_expression_repeat1 = 482, + aux_sym_bitwise_xor_expression_repeat1 = 483, + aux_sym_bitwise_and_expression_repeat1 = 484, + aux_sym_shift_expression_repeat1 = 485, + aux_sym_additive_expression_repeat1 = 486, + aux_sym_multiplicative_expression_repeat1 = 487, + aux_sym__argument_list_repeat1 = 488, + aux_sym_cascade_section_repeat1 = 489, + aux_sym_cascade_section_repeat2 = 490, + aux_sym_type_arguments_repeat1 = 491, + aux_sym_block_repeat1 = 492, + aux_sym_switch_expression_repeat1 = 493, + aux_sym__logical_or_pattern_repeat1 = 494, + aux_sym__logical_and_pattern_repeat1 = 495, + aux_sym_list_pattern_repeat1 = 496, + aux_sym_map_pattern_repeat1 = 497, + aux_sym_record_pattern_repeat1 = 498, + aux_sym_switch_block_repeat1 = 499, + aux_sym_switch_statement_case_repeat1 = 500, + aux_sym_try_statement_repeat1 = 501, + aux_sym__for_loop_parts_repeat1 = 502, + aux_sym__for_loop_parts_repeat2 = 503, + aux_sym_library_export_repeat1 = 504, + aux_sym_configurable_uri_repeat1 = 505, + aux_sym__identifier_list_repeat1 = 506, + aux_sym_enum_body_repeat1 = 507, + aux_sym_enum_body_repeat2 = 508, + aux_sym__metadata_repeat1 = 509, + aux_sym_type_parameters_repeat1 = 510, + aux_sym_extension_body_repeat1 = 511, + aux_sym_initialized_identifier_list_repeat1 = 512, + aux_sym_static_final_declaration_list_repeat1 = 513, + aux_sym_initializers_repeat1 = 514, + aux_sym_factory_constructor_signature_repeat1 = 515, + aux_sym_parameter_type_list_repeat1 = 516, + aux_sym_named_parameter_types_repeat1 = 517, + aux_sym_record_type_repeat1 = 518, + aux_sym_record_type_repeat2 = 519, + aux_sym__type_not_void_list_repeat1 = 520, + aux_sym__normal_formal_parameters_repeat1 = 521, + aux_sym__optional_postional_formal_parameters_repeat1 = 522, + aux_sym__named_formal_parameters_repeat1 = 523, + alias_sym_type_identifier = 524, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [sym_identifier] = "identifier", + [anon_sym_POUND] = "#", + [sym_decimal_integer_literal] = "decimal_integer_literal", + [sym_hex_integer_literal] = "hex_integer_literal", + [sym_decimal_floating_point_literal] = "decimal_floating_point_literal", + [anon_sym_true] = "true", + [anon_sym_false] = "false", + [anon_sym_DQUOTE] = "\"", + [anon_sym_SQUOTE] = "'", + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = "\"\"\"", + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = "'''", + [anon_sym_r_DQUOTE] = "r\"", + [anon_sym_DOLLAR] = "$", + [anon_sym_r_SQUOTE] = "r'", + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = "r\"\"\"", + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = "r'''", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [aux_sym__sub_string_test_token1] = "_sub_string_test_token1", + [sym__unused_escape_sequence] = "_unused_escape_sequence", + [anon_sym_LBRACK] = "[", + [anon_sym_COMMA] = ",", + [anon_sym_RBRACK] = "]", + [anon_sym_COLON] = ":", + [anon_sym_null] = "null", + [anon_sym_LPAREN] = "(", + [anon_sym_RPAREN] = ")", + [anon_sym_throw] = "throw", + [anon_sym_EQ] = "=", + [anon_sym_PLUS_EQ] = "+=", + [anon_sym_DASH_EQ] = "-=", + [anon_sym_STAR_EQ] = "*=", + [anon_sym_SLASH_EQ] = "/=", + [anon_sym_PERCENT_EQ] = "%=", + [anon_sym_TILDE_SLASH_EQ] = "~/=", + [anon_sym_LT_LT_EQ] = "<<=", + [anon_sym_GT_GT_EQ] = ">>=", + [anon_sym_GT_GT_GT_EQ] = ">>>=", + [anon_sym_AMP_EQ] = "&=", + [anon_sym_CARET_EQ] = "^=", + [anon_sym_PIPE_EQ] = "|=", + [anon_sym_QMARK_QMARK_EQ] = "\?\?=", + [anon_sym_QMARK_QMARK] = "\?\?", + [anon_sym_QMARK] = "\?", + [sym_equality_operator] = "equality_operator", + [anon_sym_LT] = "<", + [anon_sym_GT] = ">", + [anon_sym_LT_EQ] = "<=", + [anon_sym_GT_EQ] = ">=", + [anon_sym_PIPE] = "|", + [anon_sym_CARET] = "^", + [anon_sym_AMP] = "&", + [anon_sym_LT_LT] = "<<", + [anon_sym_GT_GT] = ">>", + [anon_sym_GT_GT_GT] = ">>>", + [sym__additive_operator] = "_additive_operator", + [anon_sym_STAR] = "*", + [anon_sym_SLASH] = "/", + [anon_sym_PERCENT] = "%", + [anon_sym_TILDE_SLASH] = "~/", + [sym_increment_operator] = "increment_operator", + [anon_sym_DOT_DOT_DOT] = "...", + [sym_minus_operator] = "minus_operator", + [anon_sym_BANG] = "!", + [anon_sym_TILDE] = "~", + [anon_sym_await] = "await", + [anon_sym_is] = "is", + [anon_sym_as] = "as", + [anon_sym_DOT] = ".", + [anon_sym_DOT_DOT] = "..", + [anon_sym_QMARK_DOT_DOT] = "\?..", + [anon_sym_QMARK_DOT] = "\?.", + [anon_sym_SEMI] = ";", + [anon_sym_switch] = "switch", + [anon_sym_EQ_GT] = "=>", + [anon_sym_when] = "when", + [anon_sym_default] = "default", + [anon_sym_do] = "do", + [anon_sym_while] = "while", + [anon_sym_continue] = "continue", + [anon_sym_yield] = "yield", + [anon_sym_return] = "return", + [anon_sym_on] = "on", + [anon_sym_try] = "try", + [anon_sym_catch] = "catch", + [anon_sym_finally] = "finally", + [anon_sym_if] = "if", + [anon_sym_case] = "case", + [anon_sym_else] = "else", + [anon_sym_for] = "for", + [anon_sym_in] = "in", + [anon_sym_AT] = "@", + [anon_sym_part] = "part", + [anon_sym_EQ_EQ] = "==", + [anon_sym_show] = "show", + [anon_sym_hide] = "hide", + [anon_sym_enum] = "enum", + [anon_sym_final] = "final", + [anon_sym_inline] = "inline", + [anon_sym_class] = "class", + [anon_sym_extension] = "extension", + [anon_sym_type] = "type", + [anon_sym_extends] = "extends", + [anon_sym_with] = "with", + [anon_sym_LBRACK_RBRACK] = "[]", + [anon_sym_LBRACK_RBRACK_EQ] = "[]=", + [sym_void_type] = "void_type", + [anon_sym_var] = "var", + [anon_sym_async] = "async", + [anon_sym_async_STAR] = "async*", + [anon_sym_sync_STAR] = "sync*", + [anon_sym_POUND_BANG] = "#!", + [aux_sym_script_tag_token1] = "script_tag_token1", + [anon_sym_LF] = "\n", + [anon_sym_library] = "library", + [sym_break_builtin] = "break_builtin", + [sym_assert_builtin] = "assert_builtin", + [sym_rethrow_builtin] = "rethrow_builtin", + [sym_part_of_builtin] = "part_of_builtin", + [anon_sym_covariant] = "covariant", + [anon_sym_deferred] = "deferred", + [anon_sym_export] = "export", + [anon_sym_factory] = "factory", + [anon_sym_Function] = "Function", + [anon_sym_get] = "get", + [anon_sym_native] = "native", + [anon_sym_implements] = "implements", + [anon_sym_import] = "import", + [anon_sym_interface] = "interface", + [anon_sym_base] = "base", + [anon_sym_abstract] = "abstract", + [anon_sym_sealed] = "sealed", + [anon_sym_operator] = "operator", + [anon_sym_mixin] = "mixin", + [anon_sym_required] = "required", + [anon_sym_set] = "set", + [anon_sym_static] = "static", + [anon_sym_typedef] = "typedef", + [anon_sym_new] = "new", + [anon_sym_AMP_AMP] = "&&", + [anon_sym_PIPE_PIPE] = "||", + [sym_const_builtin] = "const_builtin", + [anon_sym_late] = "late", + [anon_sym_external] = "external", + [anon_sym_this] = "this", + [anon_sym_super] = "super", + [sym_identifier_dollar_escaped] = "identifier_dollar_escaped", + [anon_sym_SLASH_SLASH] = "//", + [aux_sym_comment_token1] = "comment_token1", + [anon_sym_SLASH_STAR] = "/*", + [aux_sym_comment_token2] = "comment_token2", + [anon_sym_SLASH_SLASH_SLASH] = "///", + [aux_sym_documentation_comment_token1] = "documentation_comment_token1", + [sym__template_chars_double] = "_template_chars_double", + [sym__template_chars_single] = "_template_chars_single", + [sym__template_chars_double_single] = "_template_chars_double_single", + [sym__template_chars_single_single] = "_template_chars_single_single", + [sym__template_chars_raw_slash] = "_template_chars_raw_slash", + [sym__block_comment] = "_block_comment", + [sym__documentation_block_comment] = "_documentation_block_comment", + [sym_program] = "program", + [sym__top_level_definition] = "_top_level_definition", + [sym__bool_literal] = "_bool_literal", + [sym__numeric_literal] = "_numeric_literal", + [sym__literal] = "_literal", + [sym_symbol_literal] = "symbol_literal", + [sym_true] = "true", + [sym_false] = "false", + [sym_string_literal] = "string_literal", + [sym__string_literal_double_quotes] = "_string_literal_double_quotes", + [sym__string_literal_single_quotes] = "_string_literal_single_quotes", + [sym__string_literal_double_quotes_multiple] = "_string_literal_double_quotes_multiple", + [sym__string_literal_single_quotes_multiple] = "_string_literal_single_quotes_multiple", + [sym__raw_string_literal_double_quotes] = "_raw_string_literal_double_quotes", + [sym__raw_string_literal_single_quotes] = "_raw_string_literal_single_quotes", + [sym__raw_string_literal_double_quotes_multiple] = "_raw_string_literal_double_quotes_multiple", + [sym__raw_string_literal_single_quotes_multiple] = "_raw_string_literal_single_quotes_multiple", + [sym_template_substitution] = "template_substitution", + [sym__sub_string_test] = "_sub_string_test", + [sym_escape_sequence] = "escape_sequence", + [sym_list_literal] = "list_literal", + [sym_set_or_map_literal] = "set_or_map_literal", + [sym_pair] = "pair", + [sym__element] = "_element", + [sym_null_literal] = "null_literal", + [sym_record_literal] = "record_literal", + [sym__record_literal_no_const] = "_record_literal_no_const", + [sym_record_field] = "record_field", + [sym__expression] = "_expression", + [sym__expression_without_cascade] = "_expression_without_cascade", + [sym__real_expression] = "_real_expression", + [sym_throw_expression] = "throw_expression", + [sym_throw_expression_without_cascade] = "throw_expression_without_cascade", + [sym_rethrow_expression] = "rethrow_expression", + [sym_assignment_expression] = "assignment_expression", + [sym_assignment_expression_without_cascade] = "assignment_expression_without_cascade", + [sym_assignable_expression] = "assignable_expression", + [sym__assignable_selector_part] = "_assignable_selector_part", + [sym__assignment_operator] = "_assignment_operator", + [sym_lambda_expression] = "lambda_expression", + [sym_function_expression] = "function_expression", + [sym_if_null_expression] = "if_null_expression", + [aux_sym__if_null_expression] = "_if_null_expression", + [sym_conditional_expression] = "conditional_expression", + [sym_logical_or_expression] = "logical_or_expression", + [sym_logical_and_expression] = "logical_and_expression", + [sym_equality_expression] = "equality_expression", + [sym_type_cast_expression] = "type_cast_expression", + [sym_type_test_expression] = "type_test_expression", + [sym_relational_expression] = "relational_expression", + [sym_relational_operator] = "relational_operator", + [sym_bitwise_or_expression] = "bitwise_or_expression", + [sym_bitwise_xor_expression] = "bitwise_xor_expression", + [sym_bitwise_and_expression] = "bitwise_and_expression", + [sym_shift_expression] = "shift_expression", + [sym_additive_expression] = "additive_expression", + [sym_multiplicative_expression] = "multiplicative_expression", + [sym_bitwise_operator] = "bitwise_operator", + [sym__bitwise_operator] = "_bitwise_operator", + [sym_shift_operator] = "shift_operator", + [sym__shift_operator] = "_shift_operator", + [sym_additive_operator] = "additive_operator", + [sym_multiplicative_operator] = "multiplicative_operator", + [sym__multiplicative_operator] = "_multiplicative_operator", + [sym__unary_expression] = "_unary_expression", + [sym_unary_expression] = "unary_expression", + [sym__postfix_expression] = "_postfix_expression", + [sym_postfix_expression] = "postfix_expression", + [sym_postfix_operator] = "postfix_operator", + [sym_spread_element] = "spread_element", + [sym_selector] = "selector", + [sym_prefix_operator] = "prefix_operator", + [sym_negation_operator] = "negation_operator", + [sym__exclamation_operator] = "_exclamation_operator", + [sym_tilde_operator] = "tilde_operator", + [sym_await_expression] = "await_expression", + [sym_type_test] = "type_test", + [sym_is_operator] = "is_operator", + [sym_type_cast] = "type_cast", + [sym_as_operator] = "as_operator", + [sym_new_expression] = "new_expression", + [sym__dot_identifier] = "_dot_identifier", + [sym_const_object_expression] = "const_object_expression", + [sym__primary] = "_primary", + [sym_parenthesized_expression] = "parenthesized_expression", + [sym_constructor_invocation] = "constructor_invocation", + [sym_constructor_tearoff] = "constructor_tearoff", + [sym_arguments] = "arguments", + [sym__argument_list] = "_argument_list", + [sym__any_argument] = "_any_argument", + [sym_argument] = "argument", + [sym_named_argument] = "named_argument", + [sym_cascade_section] = "cascade_section", + [sym__cascade_subsection] = "_cascade_subsection", + [sym__cascade_assignment_section] = "_cascade_assignment_section", + [sym_index_selector] = "index_selector", + [sym_cascade_selector] = "cascade_selector", + [sym_argument_part] = "argument_part", + [sym_unconditional_assignable_selector] = "unconditional_assignable_selector", + [sym_conditional_assignable_selector] = "conditional_assignable_selector", + [sym__assignable_selector] = "_assignable_selector", + [sym_type_arguments] = "type_arguments", + [sym__statement] = "_statement", + [sym_local_function_declaration] = "local_function_declaration", + [sym_block] = "block", + [sym_expression_statement] = "expression_statement", + [sym_assert_statement] = "assert_statement", + [sym_assertion] = "assertion", + [sym_assertion_arguments] = "assertion_arguments", + [sym_switch_statement] = "switch_statement", + [sym_switch_expression] = "switch_expression", + [sym_switch_expression_case] = "switch_expression_case", + [sym__guarded_pattern] = "_guarded_pattern", + [sym__pattern] = "_pattern", + [sym__logical_or_pattern] = "_logical_or_pattern", + [sym__logical_and_pattern] = "_logical_and_pattern", + [sym__relational_pattern] = "_relational_pattern", + [sym__unary_pattern] = "_unary_pattern", + [sym__primary_pattern] = "_primary_pattern", + [sym_cast_pattern] = "cast_pattern", + [sym_null_check_pattern] = "null_check_pattern", + [sym_null_assert_pattern] = "null_assert_pattern", + [sym_constant_pattern] = "constant_pattern", + [sym_variable_pattern] = "variable_pattern", + [sym__parenthesized_pattern] = "_parenthesized_pattern", + [sym_list_pattern] = "list_pattern", + [sym__list_pattern_element] = "_list_pattern_element", + [sym_rest_pattern] = "rest_pattern", + [sym_map_pattern] = "map_pattern", + [sym__map_pattern_entry] = "_map_pattern_entry", + [sym_record_pattern] = "record_pattern", + [sym__pattern_field] = "_pattern_field", + [sym_object_pattern] = "object_pattern", + [sym_pattern_variable_declaration] = "pattern_variable_declaration", + [sym__outer_pattern] = "_outer_pattern", + [sym_pattern_assignment] = "pattern_assignment", + [sym_switch_block] = "switch_block", + [sym_switch_statement_case] = "switch_statement_case", + [sym_switch_statement_default] = "switch_statement_default", + [sym_do_statement] = "do_statement", + [sym_break_statement] = "break_statement", + [sym_continue_statement] = "continue_statement", + [sym_yield_statement] = "yield_statement", + [sym_yield_each_statement] = "yield_each_statement", + [sym_return_statement] = "return_statement", + [sym_try_statement] = "try_statement", + [sym__on_part] = "_on_part", + [sym__try_head] = "_try_head", + [sym_catch_clause] = "catch_clause", + [sym_catch_parameters] = "catch_parameters", + [sym_finally_clause] = "finally_clause", + [sym_if_element] = "if_element", + [sym_if_statement] = "if_statement", + [sym_while_statement] = "while_statement", + [sym_for_statement] = "for_statement", + [sym_for_loop_parts] = "for_loop_parts", + [sym__for_loop_parts] = "_for_loop_parts", + [sym_for_element] = "for_element", + [sym_annotation] = "annotation", + [sym_import_or_export] = "import_or_export", + [sym_library_import] = "library_import", + [sym_library_export] = "library_export", + [sym_import_specification] = "import_specification", + [sym_part_directive] = "part_directive", + [sym_part_of_directive] = "part_of_directive", + [sym_uri] = "uri", + [sym_configurable_uri] = "configurable_uri", + [sym_configuration_uri] = "configuration_uri", + [sym_configuration_uri_condition] = "configuration_uri_condition", + [sym_uri_test] = "uri_test", + [sym_combinator] = "combinator", + [sym__identifier_list] = "_identifier_list", + [sym_enum_declaration] = "enum_declaration", + [sym_enum_body] = "enum_body", + [sym_enum_constant] = "enum_constant", + [sym_type_alias] = "type_alias", + [sym__class_modifiers] = "_class_modifiers", + [sym__mixin_class_modifiers] = "_mixin_class_modifiers", + [sym_class_definition] = "class_definition", + [sym_extension_declaration] = "extension_declaration", + [sym_extension_type_declaration] = "extension_type_declaration", + [sym_representation_declaration] = "representation_declaration", + [sym__metadata] = "_metadata", + [sym_type_parameters] = "type_parameters", + [sym_type_parameter] = "type_parameter", + [sym_type_bound] = "type_bound", + [sym_superclass] = "superclass", + [sym_mixins] = "mixins", + [sym_mixin_application_class] = "mixin_application_class", + [sym_mixin_application] = "mixin_application", + [sym_mixin_declaration] = "mixin_declaration", + [sym_interfaces] = "interfaces", + [sym_class_body] = "class_body", + [sym_extension_body] = "extension_body", + [sym_getter_signature] = "getter_signature", + [sym_setter_signature] = "setter_signature", + [sym_method_signature] = "method_signature", + [sym_declaration] = "declaration", + [sym_identifier_list] = "identifier_list", + [sym_initialized_identifier_list] = "initialized_identifier_list", + [sym_initialized_identifier] = "initialized_identifier", + [sym_static_final_declaration_list] = "static_final_declaration_list", + [sym_binary_operator] = "binary_operator", + [sym_operator_signature] = "operator_signature", + [sym_static_final_declaration] = "static_final_declaration", + [sym__external_and_static] = "_external_and_static", + [sym__final_or_const] = "_final_or_const", + [sym_initializers] = "initializers", + [sym_initializer_list_entry] = "initializer_list_entry", + [sym_field_initializer] = "field_initializer", + [sym_factory_constructor_signature] = "factory_constructor_signature", + [sym_redirecting_factory_constructor_signature] = "redirecting_factory_constructor_signature", + [sym_redirection] = "redirection", + [sym_constructor_signature] = "constructor_signature", + [sym_constant_constructor_signature] = "constant_constructor_signature", + [sym_scoped_identifier] = "scoped_identifier", + [sym_initialized_variable_definition] = "initialized_variable_definition", + [sym__declared_identifier] = "_declared_identifier", + [sym__final_const_var_or_type] = "_final_const_var_or_type", + [sym__type] = "_type", + [sym__type_not_function] = "_type_not_function", + [sym__type_not_void_not_function] = "_type_not_void_not_function", + [sym_function_type] = "function_type", + [aux_sym__function_type_tails] = "_function_type_tails", + [sym__function_type_tail] = "_function_type_tail", + [sym_parameter_type_list] = "parameter_type_list", + [sym_normal_parameter_type] = "normal_parameter_type", + [sym_optional_parameter_types] = "optional_parameter_types", + [sym_optional_positional_parameter_types] = "optional_positional_parameter_types", + [sym_named_parameter_types] = "named_parameter_types", + [sym__named_parameter_type] = "_named_parameter_type", + [sym__type_not_void] = "_type_not_void", + [sym_record_type] = "record_type", + [sym_record_type_field] = "record_type_field", + [sym_record_type_named_field] = "record_type_named_field", + [sym__type_not_void_list] = "_type_not_void_list", + [sym__type_name] = "_type_name", + [sym__type_dot_identifier] = "_type_dot_identifier", + [sym_typed_identifier] = "typed_identifier", + [sym_nullable_type] = "nullable_type", + [sym_nullable_selector] = "nullable_selector", + [sym__var_or_type] = "_var_or_type", + [sym__final_var_or_type] = "_final_var_or_type", + [sym_inferred_type] = "inferred_type", + [sym_function_body] = "function_body", + [sym_function_expression_body] = "function_expression_body", + [sym_function_signature] = "function_signature", + [sym__formal_parameter_part] = "_formal_parameter_part", + [sym_formal_parameter_list] = "formal_parameter_list", + [sym__strict_formal_parameter_list] = "_strict_formal_parameter_list", + [sym__normal_formal_parameters] = "_normal_formal_parameters", + [sym_optional_formal_parameters] = "optional_formal_parameters", + [sym__optional_postional_formal_parameters] = "_optional_postional_formal_parameters", + [sym__named_formal_parameters] = "_named_formal_parameters", + [sym_formal_parameter] = "formal_parameter", + [sym__default_formal_parameter] = "_default_formal_parameter", + [sym__default_named_parameter] = "_default_named_parameter", + [sym__normal_formal_parameter] = "_normal_formal_parameter", + [sym__function_formal_parameter] = "_function_formal_parameter", + [sym__simple_formal_parameter] = "_simple_formal_parameter", + [sym_super_formal_parameter] = "super_formal_parameter", + [sym_constructor_param] = "constructor_param", + [sym_local_variable_declaration] = "local_variable_declaration", + [sym_script_tag] = "script_tag", + [sym_library_name] = "library_name", + [sym_dotted_identifier_list] = "dotted_identifier_list", + [sym__identifier_or_new] = "_identifier_or_new", + [sym_qualified] = "qualified", + [sym__as] = "_as", + [sym_case_builtin] = "case_builtin", + [sym__covariant] = "_covariant", + [sym__deferred] = "_deferred", + [sym__export] = "_export", + [sym__external] = "_external", + [sym__factory] = "_factory", + [sym__function_builtin_identifier] = "_function_builtin_identifier", + [sym__get] = "_get", + [sym__native] = "_native", + [sym__implements] = "_implements", + [sym__import] = "_import", + [sym_interface] = "interface", + [sym_base] = "base", + [sym_abstract] = "abstract", + [sym_sealed] = "sealed", + [sym__operator] = "_operator", + [sym_mixin] = "mixin", + [sym__required] = "_required", + [sym__set] = "_set", + [sym__static] = "_static", + [sym__typedef] = "_typedef", + [sym__new_builtin] = "_new_builtin", + [sym_logical_and_operator] = "logical_and_operator", + [sym_logical_or_operator] = "logical_or_operator", + [sym_final_builtin] = "final_builtin", + [sym__late_builtin] = "_late_builtin", + [sym__external_builtin] = "_external_builtin", + [sym_this] = "this", + [sym_super] = "super", + [sym_label] = "label", + [sym__semicolon] = "_semicolon", + [sym_comment] = "comment", + [sym_documentation_comment] = "documentation_comment", + [aux_sym_program_repeat1] = "program_repeat1", + [aux_sym_program_repeat2] = "program_repeat2", + [aux_sym_program_repeat3] = "program_repeat3", + [aux_sym_program_repeat4] = "program_repeat4", + [aux_sym_string_literal_repeat1] = "string_literal_repeat1", + [aux_sym__string_literal_double_quotes_repeat1] = "_string_literal_double_quotes_repeat1", + [aux_sym__string_literal_single_quotes_repeat1] = "_string_literal_single_quotes_repeat1", + [aux_sym__string_literal_double_quotes_multiple_repeat1] = "_string_literal_double_quotes_multiple_repeat1", + [aux_sym__string_literal_single_quotes_multiple_repeat1] = "_string_literal_single_quotes_multiple_repeat1", + [aux_sym__raw_string_literal_double_quotes_repeat1] = "_raw_string_literal_double_quotes_repeat1", + [aux_sym__raw_string_literal_single_quotes_repeat1] = "_raw_string_literal_single_quotes_repeat1", + [aux_sym__raw_string_literal_double_quotes_multiple_repeat1] = "_raw_string_literal_double_quotes_multiple_repeat1", + [aux_sym__raw_string_literal_single_quotes_multiple_repeat1] = "_raw_string_literal_single_quotes_multiple_repeat1", + [aux_sym_list_literal_repeat1] = "list_literal_repeat1", + [aux_sym__record_literal_no_const_repeat1] = "_record_literal_no_const_repeat1", + [aux_sym__expression_repeat1] = "_expression_repeat1", + [aux_sym__assignable_selector_part_repeat1] = "_assignable_selector_part_repeat1", + [aux_sym_logical_or_expression_repeat1] = "logical_or_expression_repeat1", + [aux_sym_logical_and_expression_repeat1] = "logical_and_expression_repeat1", + [aux_sym_bitwise_or_expression_repeat1] = "bitwise_or_expression_repeat1", + [aux_sym_bitwise_xor_expression_repeat1] = "bitwise_xor_expression_repeat1", + [aux_sym_bitwise_and_expression_repeat1] = "bitwise_and_expression_repeat1", + [aux_sym_shift_expression_repeat1] = "shift_expression_repeat1", + [aux_sym_additive_expression_repeat1] = "additive_expression_repeat1", + [aux_sym_multiplicative_expression_repeat1] = "multiplicative_expression_repeat1", + [aux_sym__argument_list_repeat1] = "_argument_list_repeat1", + [aux_sym_cascade_section_repeat1] = "cascade_section_repeat1", + [aux_sym_cascade_section_repeat2] = "cascade_section_repeat2", + [aux_sym_type_arguments_repeat1] = "type_arguments_repeat1", + [aux_sym_block_repeat1] = "block_repeat1", + [aux_sym_switch_expression_repeat1] = "switch_expression_repeat1", + [aux_sym__logical_or_pattern_repeat1] = "_logical_or_pattern_repeat1", + [aux_sym__logical_and_pattern_repeat1] = "_logical_and_pattern_repeat1", + [aux_sym_list_pattern_repeat1] = "list_pattern_repeat1", + [aux_sym_map_pattern_repeat1] = "map_pattern_repeat1", + [aux_sym_record_pattern_repeat1] = "record_pattern_repeat1", + [aux_sym_switch_block_repeat1] = "switch_block_repeat1", + [aux_sym_switch_statement_case_repeat1] = "switch_statement_case_repeat1", + [aux_sym_try_statement_repeat1] = "try_statement_repeat1", + [aux_sym__for_loop_parts_repeat1] = "_for_loop_parts_repeat1", + [aux_sym__for_loop_parts_repeat2] = "_for_loop_parts_repeat2", + [aux_sym_library_export_repeat1] = "library_export_repeat1", + [aux_sym_configurable_uri_repeat1] = "configurable_uri_repeat1", + [aux_sym__identifier_list_repeat1] = "_identifier_list_repeat1", + [aux_sym_enum_body_repeat1] = "enum_body_repeat1", + [aux_sym_enum_body_repeat2] = "enum_body_repeat2", + [aux_sym__metadata_repeat1] = "_metadata_repeat1", + [aux_sym_type_parameters_repeat1] = "type_parameters_repeat1", + [aux_sym_extension_body_repeat1] = "extension_body_repeat1", + [aux_sym_initialized_identifier_list_repeat1] = "initialized_identifier_list_repeat1", + [aux_sym_static_final_declaration_list_repeat1] = "static_final_declaration_list_repeat1", + [aux_sym_initializers_repeat1] = "initializers_repeat1", + [aux_sym_factory_constructor_signature_repeat1] = "factory_constructor_signature_repeat1", + [aux_sym_parameter_type_list_repeat1] = "parameter_type_list_repeat1", + [aux_sym_named_parameter_types_repeat1] = "named_parameter_types_repeat1", + [aux_sym_record_type_repeat1] = "record_type_repeat1", + [aux_sym_record_type_repeat2] = "record_type_repeat2", + [aux_sym__type_not_void_list_repeat1] = "_type_not_void_list_repeat1", + [aux_sym__normal_formal_parameters_repeat1] = "_normal_formal_parameters_repeat1", + [aux_sym__optional_postional_formal_parameters_repeat1] = "_optional_postional_formal_parameters_repeat1", + [aux_sym__named_formal_parameters_repeat1] = "_named_formal_parameters_repeat1", + [alias_sym_type_identifier] = "type_identifier", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [sym_identifier] = sym_identifier, + [anon_sym_POUND] = anon_sym_POUND, + [sym_decimal_integer_literal] = sym_decimal_integer_literal, + [sym_hex_integer_literal] = sym_hex_integer_literal, + [sym_decimal_floating_point_literal] = sym_decimal_floating_point_literal, + [anon_sym_true] = anon_sym_true, + [anon_sym_false] = anon_sym_false, + [anon_sym_DQUOTE] = anon_sym_DQUOTE, + [anon_sym_SQUOTE] = anon_sym_SQUOTE, + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = anon_sym_DQUOTE_DQUOTE_DQUOTE, + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = anon_sym_SQUOTE_SQUOTE_SQUOTE, + [anon_sym_r_DQUOTE] = anon_sym_r_DQUOTE, + [anon_sym_DOLLAR] = anon_sym_DOLLAR, + [anon_sym_r_SQUOTE] = anon_sym_r_SQUOTE, + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [aux_sym__sub_string_test_token1] = aux_sym__sub_string_test_token1, + [sym__unused_escape_sequence] = sym__unused_escape_sequence, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_null] = anon_sym_null, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_throw] = anon_sym_throw, + [anon_sym_EQ] = anon_sym_EQ, + [anon_sym_PLUS_EQ] = anon_sym_PLUS_EQ, + [anon_sym_DASH_EQ] = anon_sym_DASH_EQ, + [anon_sym_STAR_EQ] = anon_sym_STAR_EQ, + [anon_sym_SLASH_EQ] = anon_sym_SLASH_EQ, + [anon_sym_PERCENT_EQ] = anon_sym_PERCENT_EQ, + [anon_sym_TILDE_SLASH_EQ] = anon_sym_TILDE_SLASH_EQ, + [anon_sym_LT_LT_EQ] = anon_sym_LT_LT_EQ, + [anon_sym_GT_GT_EQ] = anon_sym_GT_GT_EQ, + [anon_sym_GT_GT_GT_EQ] = anon_sym_GT_GT_GT_EQ, + [anon_sym_AMP_EQ] = anon_sym_AMP_EQ, + [anon_sym_CARET_EQ] = anon_sym_CARET_EQ, + [anon_sym_PIPE_EQ] = anon_sym_PIPE_EQ, + [anon_sym_QMARK_QMARK_EQ] = anon_sym_QMARK_QMARK_EQ, + [anon_sym_QMARK_QMARK] = anon_sym_QMARK_QMARK, + [anon_sym_QMARK] = anon_sym_QMARK, + [sym_equality_operator] = sym_equality_operator, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_LT_EQ] = anon_sym_LT_EQ, + [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_PIPE] = anon_sym_PIPE, + [anon_sym_CARET] = anon_sym_CARET, + [anon_sym_AMP] = anon_sym_AMP, + [anon_sym_LT_LT] = anon_sym_LT_LT, + [anon_sym_GT_GT] = anon_sym_GT_GT, + [anon_sym_GT_GT_GT] = anon_sym_GT_GT_GT, + [sym__additive_operator] = sym__additive_operator, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_PERCENT] = anon_sym_PERCENT, + [anon_sym_TILDE_SLASH] = anon_sym_TILDE_SLASH, + [sym_increment_operator] = sym_increment_operator, + [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, + [sym_minus_operator] = sym_minus_operator, + [anon_sym_BANG] = anon_sym_BANG, + [anon_sym_TILDE] = anon_sym_TILDE, + [anon_sym_await] = anon_sym_await, + [anon_sym_is] = anon_sym_is, + [anon_sym_as] = anon_sym_as, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, + [anon_sym_QMARK_DOT_DOT] = anon_sym_QMARK_DOT_DOT, + [anon_sym_QMARK_DOT] = anon_sym_QMARK_DOT, + [anon_sym_SEMI] = anon_sym_SEMI, + [anon_sym_switch] = anon_sym_switch, + [anon_sym_EQ_GT] = anon_sym_EQ_GT, + [anon_sym_when] = anon_sym_when, + [anon_sym_default] = anon_sym_default, + [anon_sym_do] = anon_sym_do, + [anon_sym_while] = anon_sym_while, + [anon_sym_continue] = anon_sym_continue, + [anon_sym_yield] = anon_sym_yield, + [anon_sym_return] = anon_sym_return, + [anon_sym_on] = anon_sym_on, + [anon_sym_try] = anon_sym_try, + [anon_sym_catch] = anon_sym_catch, + [anon_sym_finally] = anon_sym_finally, + [anon_sym_if] = anon_sym_if, + [anon_sym_case] = anon_sym_case, + [anon_sym_else] = anon_sym_else, + [anon_sym_for] = anon_sym_for, + [anon_sym_in] = anon_sym_in, + [anon_sym_AT] = anon_sym_AT, + [anon_sym_part] = anon_sym_part, + [anon_sym_EQ_EQ] = anon_sym_EQ_EQ, + [anon_sym_show] = anon_sym_show, + [anon_sym_hide] = anon_sym_hide, + [anon_sym_enum] = anon_sym_enum, + [anon_sym_final] = anon_sym_final, + [anon_sym_inline] = anon_sym_inline, + [anon_sym_class] = anon_sym_class, + [anon_sym_extension] = anon_sym_extension, + [anon_sym_type] = anon_sym_type, + [anon_sym_extends] = anon_sym_extends, + [anon_sym_with] = anon_sym_with, + [anon_sym_LBRACK_RBRACK] = anon_sym_LBRACK_RBRACK, + [anon_sym_LBRACK_RBRACK_EQ] = anon_sym_LBRACK_RBRACK_EQ, + [sym_void_type] = sym_void_type, + [anon_sym_var] = anon_sym_var, + [anon_sym_async] = anon_sym_async, + [anon_sym_async_STAR] = anon_sym_async_STAR, + [anon_sym_sync_STAR] = anon_sym_sync_STAR, + [anon_sym_POUND_BANG] = anon_sym_POUND_BANG, + [aux_sym_script_tag_token1] = aux_sym_script_tag_token1, + [anon_sym_LF] = anon_sym_LF, + [anon_sym_library] = anon_sym_library, + [sym_break_builtin] = sym_break_builtin, + [sym_assert_builtin] = sym_assert_builtin, + [sym_rethrow_builtin] = sym_rethrow_builtin, + [sym_part_of_builtin] = sym_part_of_builtin, + [anon_sym_covariant] = anon_sym_covariant, + [anon_sym_deferred] = anon_sym_deferred, + [anon_sym_export] = anon_sym_export, + [anon_sym_factory] = anon_sym_factory, + [anon_sym_Function] = anon_sym_Function, + [anon_sym_get] = anon_sym_get, + [anon_sym_native] = anon_sym_native, + [anon_sym_implements] = anon_sym_implements, + [anon_sym_import] = anon_sym_import, + [anon_sym_interface] = anon_sym_interface, + [anon_sym_base] = anon_sym_base, + [anon_sym_abstract] = anon_sym_abstract, + [anon_sym_sealed] = anon_sym_sealed, + [anon_sym_operator] = anon_sym_operator, + [anon_sym_mixin] = anon_sym_mixin, + [anon_sym_required] = anon_sym_required, + [anon_sym_set] = anon_sym_set, + [anon_sym_static] = anon_sym_static, + [anon_sym_typedef] = anon_sym_typedef, + [anon_sym_new] = anon_sym_new, + [anon_sym_AMP_AMP] = anon_sym_AMP_AMP, + [anon_sym_PIPE_PIPE] = anon_sym_PIPE_PIPE, + [sym_const_builtin] = sym_const_builtin, + [anon_sym_late] = anon_sym_late, + [anon_sym_external] = anon_sym_external, + [anon_sym_this] = anon_sym_this, + [anon_sym_super] = anon_sym_super, + [sym_identifier_dollar_escaped] = sym_identifier_dollar_escaped, + [anon_sym_SLASH_SLASH] = anon_sym_SLASH_SLASH, + [aux_sym_comment_token1] = aux_sym_comment_token1, + [anon_sym_SLASH_STAR] = anon_sym_SLASH_STAR, + [aux_sym_comment_token2] = aux_sym_comment_token2, + [anon_sym_SLASH_SLASH_SLASH] = anon_sym_SLASH_SLASH_SLASH, + [aux_sym_documentation_comment_token1] = aux_sym_documentation_comment_token1, + [sym__template_chars_double] = sym__template_chars_double, + [sym__template_chars_single] = sym__template_chars_single, + [sym__template_chars_double_single] = sym__template_chars_double_single, + [sym__template_chars_single_single] = sym__template_chars_single_single, + [sym__template_chars_raw_slash] = sym__template_chars_raw_slash, + [sym__block_comment] = sym__block_comment, + [sym__documentation_block_comment] = sym__documentation_block_comment, + [sym_program] = sym_program, + [sym__top_level_definition] = sym__top_level_definition, + [sym__bool_literal] = sym__bool_literal, + [sym__numeric_literal] = sym__numeric_literal, + [sym__literal] = sym__literal, + [sym_symbol_literal] = sym_symbol_literal, + [sym_true] = sym_true, + [sym_false] = sym_false, + [sym_string_literal] = sym_string_literal, + [sym__string_literal_double_quotes] = sym__string_literal_double_quotes, + [sym__string_literal_single_quotes] = sym__string_literal_single_quotes, + [sym__string_literal_double_quotes_multiple] = sym__string_literal_double_quotes_multiple, + [sym__string_literal_single_quotes_multiple] = sym__string_literal_single_quotes_multiple, + [sym__raw_string_literal_double_quotes] = sym__raw_string_literal_double_quotes, + [sym__raw_string_literal_single_quotes] = sym__raw_string_literal_single_quotes, + [sym__raw_string_literal_double_quotes_multiple] = sym__raw_string_literal_double_quotes_multiple, + [sym__raw_string_literal_single_quotes_multiple] = sym__raw_string_literal_single_quotes_multiple, + [sym_template_substitution] = sym_template_substitution, + [sym__sub_string_test] = sym__sub_string_test, + [sym_escape_sequence] = sym_escape_sequence, + [sym_list_literal] = sym_list_literal, + [sym_set_or_map_literal] = sym_set_or_map_literal, + [sym_pair] = sym_pair, + [sym__element] = sym__element, + [sym_null_literal] = sym_null_literal, + [sym_record_literal] = sym_record_literal, + [sym__record_literal_no_const] = sym__record_literal_no_const, + [sym_record_field] = sym_record_field, + [sym__expression] = sym__expression, + [sym__expression_without_cascade] = sym__expression_without_cascade, + [sym__real_expression] = sym__real_expression, + [sym_throw_expression] = sym_throw_expression, + [sym_throw_expression_without_cascade] = sym_throw_expression_without_cascade, + [sym_rethrow_expression] = sym_rethrow_expression, + [sym_assignment_expression] = sym_assignment_expression, + [sym_assignment_expression_without_cascade] = sym_assignment_expression_without_cascade, + [sym_assignable_expression] = sym_assignable_expression, + [sym__assignable_selector_part] = sym__assignable_selector_part, + [sym__assignment_operator] = sym__assignment_operator, + [sym_lambda_expression] = sym_lambda_expression, + [sym_function_expression] = sym_function_expression, + [sym_if_null_expression] = sym_if_null_expression, + [aux_sym__if_null_expression] = aux_sym__if_null_expression, + [sym_conditional_expression] = sym_conditional_expression, + [sym_logical_or_expression] = sym_logical_or_expression, + [sym_logical_and_expression] = sym_logical_and_expression, + [sym_equality_expression] = sym_equality_expression, + [sym_type_cast_expression] = sym_type_cast_expression, + [sym_type_test_expression] = sym_type_test_expression, + [sym_relational_expression] = sym_relational_expression, + [sym_relational_operator] = sym_relational_operator, + [sym_bitwise_or_expression] = sym_bitwise_or_expression, + [sym_bitwise_xor_expression] = sym_bitwise_xor_expression, + [sym_bitwise_and_expression] = sym_bitwise_and_expression, + [sym_shift_expression] = sym_shift_expression, + [sym_additive_expression] = sym_additive_expression, + [sym_multiplicative_expression] = sym_multiplicative_expression, + [sym_bitwise_operator] = sym_bitwise_operator, + [sym__bitwise_operator] = sym__bitwise_operator, + [sym_shift_operator] = sym_shift_operator, + [sym__shift_operator] = sym__shift_operator, + [sym_additive_operator] = sym_additive_operator, + [sym_multiplicative_operator] = sym_multiplicative_operator, + [sym__multiplicative_operator] = sym__multiplicative_operator, + [sym__unary_expression] = sym__unary_expression, + [sym_unary_expression] = sym_unary_expression, + [sym__postfix_expression] = sym__postfix_expression, + [sym_postfix_expression] = sym_postfix_expression, + [sym_postfix_operator] = sym_postfix_operator, + [sym_spread_element] = sym_spread_element, + [sym_selector] = sym_selector, + [sym_prefix_operator] = sym_prefix_operator, + [sym_negation_operator] = sym_negation_operator, + [sym__exclamation_operator] = sym__exclamation_operator, + [sym_tilde_operator] = sym_tilde_operator, + [sym_await_expression] = sym_await_expression, + [sym_type_test] = sym_type_test, + [sym_is_operator] = sym_is_operator, + [sym_type_cast] = sym_type_cast, + [sym_as_operator] = sym_as_operator, + [sym_new_expression] = sym_new_expression, + [sym__dot_identifier] = sym__dot_identifier, + [sym_const_object_expression] = sym_const_object_expression, + [sym__primary] = sym__primary, + [sym_parenthesized_expression] = sym_parenthesized_expression, + [sym_constructor_invocation] = sym_constructor_invocation, + [sym_constructor_tearoff] = sym_constructor_tearoff, + [sym_arguments] = sym_arguments, + [sym__argument_list] = sym__argument_list, + [sym__any_argument] = sym__any_argument, + [sym_argument] = sym_argument, + [sym_named_argument] = sym_named_argument, + [sym_cascade_section] = sym_cascade_section, + [sym__cascade_subsection] = sym__cascade_subsection, + [sym__cascade_assignment_section] = sym__cascade_assignment_section, + [sym_index_selector] = sym_index_selector, + [sym_cascade_selector] = sym_cascade_selector, + [sym_argument_part] = sym_argument_part, + [sym_unconditional_assignable_selector] = sym_unconditional_assignable_selector, + [sym_conditional_assignable_selector] = sym_conditional_assignable_selector, + [sym__assignable_selector] = sym__assignable_selector, + [sym_type_arguments] = sym_type_arguments, + [sym__statement] = sym__statement, + [sym_local_function_declaration] = sym_local_function_declaration, + [sym_block] = sym_block, + [sym_expression_statement] = sym_expression_statement, + [sym_assert_statement] = sym_assert_statement, + [sym_assertion] = sym_assertion, + [sym_assertion_arguments] = sym_assertion_arguments, + [sym_switch_statement] = sym_switch_statement, + [sym_switch_expression] = sym_switch_expression, + [sym_switch_expression_case] = sym_switch_expression_case, + [sym__guarded_pattern] = sym__guarded_pattern, + [sym__pattern] = sym__pattern, + [sym__logical_or_pattern] = sym__logical_or_pattern, + [sym__logical_and_pattern] = sym__logical_and_pattern, + [sym__relational_pattern] = sym__relational_pattern, + [sym__unary_pattern] = sym__unary_pattern, + [sym__primary_pattern] = sym__primary_pattern, + [sym_cast_pattern] = sym_cast_pattern, + [sym_null_check_pattern] = sym_null_check_pattern, + [sym_null_assert_pattern] = sym_null_assert_pattern, + [sym_constant_pattern] = sym_constant_pattern, + [sym_variable_pattern] = sym_variable_pattern, + [sym__parenthesized_pattern] = sym__parenthesized_pattern, + [sym_list_pattern] = sym_list_pattern, + [sym__list_pattern_element] = sym__list_pattern_element, + [sym_rest_pattern] = sym_rest_pattern, + [sym_map_pattern] = sym_map_pattern, + [sym__map_pattern_entry] = sym__map_pattern_entry, + [sym_record_pattern] = sym_record_pattern, + [sym__pattern_field] = sym__pattern_field, + [sym_object_pattern] = sym_object_pattern, + [sym_pattern_variable_declaration] = sym_pattern_variable_declaration, + [sym__outer_pattern] = sym__outer_pattern, + [sym_pattern_assignment] = sym_pattern_assignment, + [sym_switch_block] = sym_switch_block, + [sym_switch_statement_case] = sym_switch_statement_case, + [sym_switch_statement_default] = sym_switch_statement_default, + [sym_do_statement] = sym_do_statement, + [sym_break_statement] = sym_break_statement, + [sym_continue_statement] = sym_continue_statement, + [sym_yield_statement] = sym_yield_statement, + [sym_yield_each_statement] = sym_yield_each_statement, + [sym_return_statement] = sym_return_statement, + [sym_try_statement] = sym_try_statement, + [sym__on_part] = sym__on_part, + [sym__try_head] = sym__try_head, + [sym_catch_clause] = sym_catch_clause, + [sym_catch_parameters] = sym_catch_parameters, + [sym_finally_clause] = sym_finally_clause, + [sym_if_element] = sym_if_element, + [sym_if_statement] = sym_if_statement, + [sym_while_statement] = sym_while_statement, + [sym_for_statement] = sym_for_statement, + [sym_for_loop_parts] = sym_for_loop_parts, + [sym__for_loop_parts] = sym__for_loop_parts, + [sym_for_element] = sym_for_element, + [sym_annotation] = sym_annotation, + [sym_import_or_export] = sym_import_or_export, + [sym_library_import] = sym_library_import, + [sym_library_export] = sym_library_export, + [sym_import_specification] = sym_import_specification, + [sym_part_directive] = sym_part_directive, + [sym_part_of_directive] = sym_part_of_directive, + [sym_uri] = sym_uri, + [sym_configurable_uri] = sym_configurable_uri, + [sym_configuration_uri] = sym_configuration_uri, + [sym_configuration_uri_condition] = sym_configuration_uri_condition, + [sym_uri_test] = sym_uri_test, + [sym_combinator] = sym_combinator, + [sym__identifier_list] = sym__identifier_list, + [sym_enum_declaration] = sym_enum_declaration, + [sym_enum_body] = sym_enum_body, + [sym_enum_constant] = sym_enum_constant, + [sym_type_alias] = sym_type_alias, + [sym__class_modifiers] = sym__class_modifiers, + [sym__mixin_class_modifiers] = sym__mixin_class_modifiers, + [sym_class_definition] = sym_class_definition, + [sym_extension_declaration] = sym_extension_declaration, + [sym_extension_type_declaration] = sym_extension_type_declaration, + [sym_representation_declaration] = sym_representation_declaration, + [sym__metadata] = sym__metadata, + [sym_type_parameters] = sym_type_parameters, + [sym_type_parameter] = sym_type_parameter, + [sym_type_bound] = sym_type_bound, + [sym_superclass] = sym_superclass, + [sym_mixins] = sym_mixins, + [sym_mixin_application_class] = sym_mixin_application_class, + [sym_mixin_application] = sym_mixin_application, + [sym_mixin_declaration] = sym_mixin_declaration, + [sym_interfaces] = sym_interfaces, + [sym_class_body] = sym_class_body, + [sym_extension_body] = sym_extension_body, + [sym_getter_signature] = sym_getter_signature, + [sym_setter_signature] = sym_setter_signature, + [sym_method_signature] = sym_method_signature, + [sym_declaration] = sym_declaration, + [sym_identifier_list] = sym_identifier_list, + [sym_initialized_identifier_list] = sym_initialized_identifier_list, + [sym_initialized_identifier] = sym_initialized_identifier, + [sym_static_final_declaration_list] = sym_static_final_declaration_list, + [sym_binary_operator] = sym_binary_operator, + [sym_operator_signature] = sym_operator_signature, + [sym_static_final_declaration] = sym_static_final_declaration, + [sym__external_and_static] = sym__external_and_static, + [sym__final_or_const] = sym__final_or_const, + [sym_initializers] = sym_initializers, + [sym_initializer_list_entry] = sym_initializer_list_entry, + [sym_field_initializer] = sym_field_initializer, + [sym_factory_constructor_signature] = sym_factory_constructor_signature, + [sym_redirecting_factory_constructor_signature] = sym_redirecting_factory_constructor_signature, + [sym_redirection] = sym_redirection, + [sym_constructor_signature] = sym_constructor_signature, + [sym_constant_constructor_signature] = sym_constant_constructor_signature, + [sym_scoped_identifier] = sym_scoped_identifier, + [sym_initialized_variable_definition] = sym_initialized_variable_definition, + [sym__declared_identifier] = sym__declared_identifier, + [sym__final_const_var_or_type] = sym__final_const_var_or_type, + [sym__type] = sym__type, + [sym__type_not_function] = sym__type_not_function, + [sym__type_not_void_not_function] = sym__type_not_void_not_function, + [sym_function_type] = sym_function_type, + [aux_sym__function_type_tails] = aux_sym__function_type_tails, + [sym__function_type_tail] = sym__function_type_tail, + [sym_parameter_type_list] = sym_parameter_type_list, + [sym_normal_parameter_type] = sym_normal_parameter_type, + [sym_optional_parameter_types] = sym_optional_parameter_types, + [sym_optional_positional_parameter_types] = sym_optional_positional_parameter_types, + [sym_named_parameter_types] = sym_named_parameter_types, + [sym__named_parameter_type] = sym__named_parameter_type, + [sym__type_not_void] = sym__type_not_void, + [sym_record_type] = sym_record_type, + [sym_record_type_field] = sym_record_type_field, + [sym_record_type_named_field] = sym_record_type_named_field, + [sym__type_not_void_list] = sym__type_not_void_list, + [sym__type_name] = sym__type_name, + [sym__type_dot_identifier] = sym__type_dot_identifier, + [sym_typed_identifier] = sym_typed_identifier, + [sym_nullable_type] = sym_nullable_type, + [sym_nullable_selector] = sym_nullable_selector, + [sym__var_or_type] = sym__var_or_type, + [sym__final_var_or_type] = sym__final_var_or_type, + [sym_inferred_type] = sym_inferred_type, + [sym_function_body] = sym_function_body, + [sym_function_expression_body] = sym_function_expression_body, + [sym_function_signature] = sym_function_signature, + [sym__formal_parameter_part] = sym__formal_parameter_part, + [sym_formal_parameter_list] = sym_formal_parameter_list, + [sym__strict_formal_parameter_list] = sym__strict_formal_parameter_list, + [sym__normal_formal_parameters] = sym__normal_formal_parameters, + [sym_optional_formal_parameters] = sym_optional_formal_parameters, + [sym__optional_postional_formal_parameters] = sym__optional_postional_formal_parameters, + [sym__named_formal_parameters] = sym__named_formal_parameters, + [sym_formal_parameter] = sym_formal_parameter, + [sym__default_formal_parameter] = sym__default_formal_parameter, + [sym__default_named_parameter] = sym__default_named_parameter, + [sym__normal_formal_parameter] = sym__normal_formal_parameter, + [sym__function_formal_parameter] = sym__function_formal_parameter, + [sym__simple_formal_parameter] = sym__simple_formal_parameter, + [sym_super_formal_parameter] = sym_super_formal_parameter, + [sym_constructor_param] = sym_constructor_param, + [sym_local_variable_declaration] = sym_local_variable_declaration, + [sym_script_tag] = sym_script_tag, + [sym_library_name] = sym_library_name, + [sym_dotted_identifier_list] = sym_dotted_identifier_list, + [sym__identifier_or_new] = sym__identifier_or_new, + [sym_qualified] = sym_qualified, + [sym__as] = sym__as, + [sym_case_builtin] = sym_case_builtin, + [sym__covariant] = sym__covariant, + [sym__deferred] = sym__deferred, + [sym__export] = sym__export, + [sym__external] = sym__external, + [sym__factory] = sym__factory, + [sym__function_builtin_identifier] = sym__function_builtin_identifier, + [sym__get] = sym__get, + [sym__native] = sym__native, + [sym__implements] = sym__implements, + [sym__import] = sym__import, + [sym_interface] = sym_interface, + [sym_base] = sym_base, + [sym_abstract] = sym_abstract, + [sym_sealed] = sym_sealed, + [sym__operator] = sym__operator, + [sym_mixin] = sym_mixin, + [sym__required] = sym__required, + [sym__set] = sym__set, + [sym__static] = sym__static, + [sym__typedef] = sym__typedef, + [sym__new_builtin] = sym__new_builtin, + [sym_logical_and_operator] = sym_logical_and_operator, + [sym_logical_or_operator] = sym_logical_or_operator, + [sym_final_builtin] = sym_final_builtin, + [sym__late_builtin] = sym__late_builtin, + [sym__external_builtin] = sym__external_builtin, + [sym_this] = sym_this, + [sym_super] = sym_super, + [sym_label] = sym_label, + [sym__semicolon] = sym__semicolon, + [sym_comment] = sym_comment, + [sym_documentation_comment] = sym_documentation_comment, + [aux_sym_program_repeat1] = aux_sym_program_repeat1, + [aux_sym_program_repeat2] = aux_sym_program_repeat2, + [aux_sym_program_repeat3] = aux_sym_program_repeat3, + [aux_sym_program_repeat4] = aux_sym_program_repeat4, + [aux_sym_string_literal_repeat1] = aux_sym_string_literal_repeat1, + [aux_sym__string_literal_double_quotes_repeat1] = aux_sym__string_literal_double_quotes_repeat1, + [aux_sym__string_literal_single_quotes_repeat1] = aux_sym__string_literal_single_quotes_repeat1, + [aux_sym__string_literal_double_quotes_multiple_repeat1] = aux_sym__string_literal_double_quotes_multiple_repeat1, + [aux_sym__string_literal_single_quotes_multiple_repeat1] = aux_sym__string_literal_single_quotes_multiple_repeat1, + [aux_sym__raw_string_literal_double_quotes_repeat1] = aux_sym__raw_string_literal_double_quotes_repeat1, + [aux_sym__raw_string_literal_single_quotes_repeat1] = aux_sym__raw_string_literal_single_quotes_repeat1, + [aux_sym__raw_string_literal_double_quotes_multiple_repeat1] = aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + [aux_sym__raw_string_literal_single_quotes_multiple_repeat1] = aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + [aux_sym_list_literal_repeat1] = aux_sym_list_literal_repeat1, + [aux_sym__record_literal_no_const_repeat1] = aux_sym__record_literal_no_const_repeat1, + [aux_sym__expression_repeat1] = aux_sym__expression_repeat1, + [aux_sym__assignable_selector_part_repeat1] = aux_sym__assignable_selector_part_repeat1, + [aux_sym_logical_or_expression_repeat1] = aux_sym_logical_or_expression_repeat1, + [aux_sym_logical_and_expression_repeat1] = aux_sym_logical_and_expression_repeat1, + [aux_sym_bitwise_or_expression_repeat1] = aux_sym_bitwise_or_expression_repeat1, + [aux_sym_bitwise_xor_expression_repeat1] = aux_sym_bitwise_xor_expression_repeat1, + [aux_sym_bitwise_and_expression_repeat1] = aux_sym_bitwise_and_expression_repeat1, + [aux_sym_shift_expression_repeat1] = aux_sym_shift_expression_repeat1, + [aux_sym_additive_expression_repeat1] = aux_sym_additive_expression_repeat1, + [aux_sym_multiplicative_expression_repeat1] = aux_sym_multiplicative_expression_repeat1, + [aux_sym__argument_list_repeat1] = aux_sym__argument_list_repeat1, + [aux_sym_cascade_section_repeat1] = aux_sym_cascade_section_repeat1, + [aux_sym_cascade_section_repeat2] = aux_sym_cascade_section_repeat2, + [aux_sym_type_arguments_repeat1] = aux_sym_type_arguments_repeat1, + [aux_sym_block_repeat1] = aux_sym_block_repeat1, + [aux_sym_switch_expression_repeat1] = aux_sym_switch_expression_repeat1, + [aux_sym__logical_or_pattern_repeat1] = aux_sym__logical_or_pattern_repeat1, + [aux_sym__logical_and_pattern_repeat1] = aux_sym__logical_and_pattern_repeat1, + [aux_sym_list_pattern_repeat1] = aux_sym_list_pattern_repeat1, + [aux_sym_map_pattern_repeat1] = aux_sym_map_pattern_repeat1, + [aux_sym_record_pattern_repeat1] = aux_sym_record_pattern_repeat1, + [aux_sym_switch_block_repeat1] = aux_sym_switch_block_repeat1, + [aux_sym_switch_statement_case_repeat1] = aux_sym_switch_statement_case_repeat1, + [aux_sym_try_statement_repeat1] = aux_sym_try_statement_repeat1, + [aux_sym__for_loop_parts_repeat1] = aux_sym__for_loop_parts_repeat1, + [aux_sym__for_loop_parts_repeat2] = aux_sym__for_loop_parts_repeat2, + [aux_sym_library_export_repeat1] = aux_sym_library_export_repeat1, + [aux_sym_configurable_uri_repeat1] = aux_sym_configurable_uri_repeat1, + [aux_sym__identifier_list_repeat1] = aux_sym__identifier_list_repeat1, + [aux_sym_enum_body_repeat1] = aux_sym_enum_body_repeat1, + [aux_sym_enum_body_repeat2] = aux_sym_enum_body_repeat2, + [aux_sym__metadata_repeat1] = aux_sym__metadata_repeat1, + [aux_sym_type_parameters_repeat1] = aux_sym_type_parameters_repeat1, + [aux_sym_extension_body_repeat1] = aux_sym_extension_body_repeat1, + [aux_sym_initialized_identifier_list_repeat1] = aux_sym_initialized_identifier_list_repeat1, + [aux_sym_static_final_declaration_list_repeat1] = aux_sym_static_final_declaration_list_repeat1, + [aux_sym_initializers_repeat1] = aux_sym_initializers_repeat1, + [aux_sym_factory_constructor_signature_repeat1] = aux_sym_factory_constructor_signature_repeat1, + [aux_sym_parameter_type_list_repeat1] = aux_sym_parameter_type_list_repeat1, + [aux_sym_named_parameter_types_repeat1] = aux_sym_named_parameter_types_repeat1, + [aux_sym_record_type_repeat1] = aux_sym_record_type_repeat1, + [aux_sym_record_type_repeat2] = aux_sym_record_type_repeat2, + [aux_sym__type_not_void_list_repeat1] = aux_sym__type_not_void_list_repeat1, + [aux_sym__normal_formal_parameters_repeat1] = aux_sym__normal_formal_parameters_repeat1, + [aux_sym__optional_postional_formal_parameters_repeat1] = aux_sym__optional_postional_formal_parameters_repeat1, + [aux_sym__named_formal_parameters_repeat1] = aux_sym__named_formal_parameters_repeat1, + [alias_sym_type_identifier] = alias_sym_type_identifier, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [anon_sym_POUND] = { + .visible = true, + .named = false, + }, + [sym_decimal_integer_literal] = { + .visible = true, + .named = true, + }, + [sym_hex_integer_literal] = { + .visible = true, + .named = true, + }, + [sym_decimal_floating_point_literal] = { + .visible = true, + .named = true, + }, + [anon_sym_true] = { + .visible = true, + .named = false, + }, + [anon_sym_false] = { + .visible = true, + .named = false, + }, + [anon_sym_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_SQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_r_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_DOLLAR] = { + .visible = true, + .named = false, + }, + [anon_sym_r_SQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [aux_sym__sub_string_test_token1] = { + .visible = false, + .named = false, + }, + [sym__unused_escape_sequence] = { + .visible = false, + .named = true, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_null] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_throw] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE_SLASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK_QMARK_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK_QMARK] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK] = { + .visible = true, + .named = false, + }, + [sym_equality_operator] = { + .visible = true, + .named = true, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_GT] = { + .visible = true, + .named = false, + }, + [sym__additive_operator] = { + .visible = false, + .named = true, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE_SLASH] = { + .visible = true, + .named = false, + }, + [sym_increment_operator] = { + .visible = true, + .named = true, + }, + [anon_sym_DOT_DOT_DOT] = { + .visible = true, + .named = false, + }, + [sym_minus_operator] = { + .visible = true, + .named = true, + }, + [anon_sym_BANG] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE] = { + .visible = true, + .named = false, + }, + [anon_sym_await] = { + .visible = true, + .named = false, + }, + [anon_sym_is] = { + .visible = true, + .named = false, + }, + [anon_sym_as] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_switch] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_when] = { + .visible = true, + .named = false, + }, + [anon_sym_default] = { + .visible = true, + .named = false, + }, + [anon_sym_do] = { + .visible = true, + .named = false, + }, + [anon_sym_while] = { + .visible = true, + .named = false, + }, + [anon_sym_continue] = { + .visible = true, + .named = false, + }, + [anon_sym_yield] = { + .visible = true, + .named = false, + }, + [anon_sym_return] = { + .visible = true, + .named = false, + }, + [anon_sym_on] = { + .visible = true, + .named = false, + }, + [anon_sym_try] = { + .visible = true, + .named = false, + }, + [anon_sym_catch] = { + .visible = true, + .named = false, + }, + [anon_sym_finally] = { + .visible = true, + .named = false, + }, + [anon_sym_if] = { + .visible = true, + .named = false, + }, + [anon_sym_case] = { + .visible = true, + .named = false, + }, + [anon_sym_else] = { + .visible = true, + .named = false, + }, + [anon_sym_for] = { + .visible = true, + .named = false, + }, + [anon_sym_in] = { + .visible = true, + .named = false, + }, + [anon_sym_AT] = { + .visible = true, + .named = false, + }, + [anon_sym_part] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_show] = { + .visible = true, + .named = false, + }, + [anon_sym_hide] = { + .visible = true, + .named = false, + }, + [anon_sym_enum] = { + .visible = true, + .named = false, + }, + [anon_sym_final] = { + .visible = true, + .named = false, + }, + [anon_sym_inline] = { + .visible = true, + .named = false, + }, + [anon_sym_class] = { + .visible = true, + .named = false, + }, + [anon_sym_extension] = { + .visible = true, + .named = false, + }, + [anon_sym_type] = { + .visible = true, + .named = false, + }, + [anon_sym_extends] = { + .visible = true, + .named = false, + }, + [anon_sym_with] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK_RBRACK_EQ] = { + .visible = true, + .named = false, + }, + [sym_void_type] = { + .visible = true, + .named = true, + }, + [anon_sym_var] = { + .visible = true, + .named = false, + }, + [anon_sym_async] = { + .visible = true, + .named = false, + }, + [anon_sym_async_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_sync_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND_BANG] = { + .visible = true, + .named = false, + }, + [aux_sym_script_tag_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_LF] = { + .visible = true, + .named = false, + }, + [anon_sym_library] = { + .visible = true, + .named = false, + }, + [sym_break_builtin] = { + .visible = true, + .named = true, + }, + [sym_assert_builtin] = { + .visible = true, + .named = true, + }, + [sym_rethrow_builtin] = { + .visible = true, + .named = true, + }, + [sym_part_of_builtin] = { + .visible = true, + .named = true, + }, + [anon_sym_covariant] = { + .visible = true, + .named = false, + }, + [anon_sym_deferred] = { + .visible = true, + .named = false, + }, + [anon_sym_export] = { + .visible = true, + .named = false, + }, + [anon_sym_factory] = { + .visible = true, + .named = false, + }, + [anon_sym_Function] = { + .visible = true, + .named = false, + }, + [anon_sym_get] = { + .visible = true, + .named = false, + }, + [anon_sym_native] = { + .visible = true, + .named = false, + }, + [anon_sym_implements] = { + .visible = true, + .named = false, + }, + [anon_sym_import] = { + .visible = true, + .named = false, + }, + [anon_sym_interface] = { + .visible = true, + .named = false, + }, + [anon_sym_base] = { + .visible = true, + .named = false, + }, + [anon_sym_abstract] = { + .visible = true, + .named = false, + }, + [anon_sym_sealed] = { + .visible = true, + .named = false, + }, + [anon_sym_operator] = { + .visible = true, + .named = false, + }, + [anon_sym_mixin] = { + .visible = true, + .named = false, + }, + [anon_sym_required] = { + .visible = true, + .named = false, + }, + [anon_sym_set] = { + .visible = true, + .named = false, + }, + [anon_sym_static] = { + .visible = true, + .named = false, + }, + [anon_sym_typedef] = { + .visible = true, + .named = false, + }, + [anon_sym_new] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP_AMP] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_PIPE] = { + .visible = true, + .named = false, + }, + [sym_const_builtin] = { + .visible = true, + .named = true, + }, + [anon_sym_late] = { + .visible = true, + .named = false, + }, + [anon_sym_external] = { + .visible = true, + .named = false, + }, + [anon_sym_this] = { + .visible = true, + .named = false, + }, + [anon_sym_super] = { + .visible = true, + .named = false, + }, + [sym_identifier_dollar_escaped] = { + .visible = true, + .named = true, + }, + [anon_sym_SLASH_SLASH] = { + .visible = true, + .named = false, + }, + [aux_sym_comment_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_SLASH_STAR] = { + .visible = true, + .named = false, + }, + [aux_sym_comment_token2] = { + .visible = false, + .named = false, + }, + [anon_sym_SLASH_SLASH_SLASH] = { + .visible = true, + .named = false, + }, + [aux_sym_documentation_comment_token1] = { + .visible = false, + .named = false, + }, + [sym__template_chars_double] = { + .visible = false, + .named = true, + }, + [sym__template_chars_single] = { + .visible = false, + .named = true, + }, + [sym__template_chars_double_single] = { + .visible = false, + .named = true, + }, + [sym__template_chars_single_single] = { + .visible = false, + .named = true, + }, + [sym__template_chars_raw_slash] = { + .visible = false, + .named = true, + }, + [sym__block_comment] = { + .visible = false, + .named = true, + }, + [sym__documentation_block_comment] = { + .visible = false, + .named = true, + }, + [sym_program] = { + .visible = true, + .named = true, + }, + [sym__top_level_definition] = { + .visible = false, + .named = true, + }, + [sym__bool_literal] = { + .visible = false, + .named = true, + }, + [sym__numeric_literal] = { + .visible = false, + .named = true, + }, + [sym__literal] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_symbol_literal] = { + .visible = true, + .named = true, + }, + [sym_true] = { + .visible = true, + .named = true, + }, + [sym_false] = { + .visible = true, + .named = true, + }, + [sym_string_literal] = { + .visible = true, + .named = true, + }, + [sym__string_literal_double_quotes] = { + .visible = false, + .named = true, + }, + [sym__string_literal_single_quotes] = { + .visible = false, + .named = true, + }, + [sym__string_literal_double_quotes_multiple] = { + .visible = false, + .named = true, + }, + [sym__string_literal_single_quotes_multiple] = { + .visible = false, + .named = true, + }, + [sym__raw_string_literal_double_quotes] = { + .visible = false, + .named = true, + }, + [sym__raw_string_literal_single_quotes] = { + .visible = false, + .named = true, + }, + [sym__raw_string_literal_double_quotes_multiple] = { + .visible = false, + .named = true, + }, + [sym__raw_string_literal_single_quotes_multiple] = { + .visible = false, + .named = true, + }, + [sym_template_substitution] = { + .visible = true, + .named = true, + }, + [sym__sub_string_test] = { + .visible = false, + .named = true, + }, + [sym_escape_sequence] = { + .visible = true, + .named = true, + }, + [sym_list_literal] = { + .visible = true, + .named = true, + }, + [sym_set_or_map_literal] = { + .visible = true, + .named = true, + }, + [sym_pair] = { + .visible = true, + .named = true, + }, + [sym__element] = { + .visible = false, + .named = true, + }, + [sym_null_literal] = { + .visible = true, + .named = true, + }, + [sym_record_literal] = { + .visible = true, + .named = true, + }, + [sym__record_literal_no_const] = { + .visible = false, + .named = true, + }, + [sym_record_field] = { + .visible = true, + .named = true, + }, + [sym__expression] = { + .visible = false, + .named = true, + }, + [sym__expression_without_cascade] = { + .visible = false, + .named = true, + }, + [sym__real_expression] = { + .visible = false, + .named = true, + }, + [sym_throw_expression] = { + .visible = true, + .named = true, + }, + [sym_throw_expression_without_cascade] = { + .visible = true, + .named = true, + }, + [sym_rethrow_expression] = { + .visible = true, + .named = true, + }, + [sym_assignment_expression] = { + .visible = true, + .named = true, + }, + [sym_assignment_expression_without_cascade] = { + .visible = true, + .named = true, + }, + [sym_assignable_expression] = { + .visible = true, + .named = true, + }, + [sym__assignable_selector_part] = { + .visible = false, + .named = true, + }, + [sym__assignment_operator] = { + .visible = false, + .named = true, + }, + [sym_lambda_expression] = { + .visible = true, + .named = true, + }, + [sym_function_expression] = { + .visible = true, + .named = true, + }, + [sym_if_null_expression] = { + .visible = true, + .named = true, + }, + [aux_sym__if_null_expression] = { + .visible = false, + .named = false, + }, + [sym_conditional_expression] = { + .visible = true, + .named = true, + }, + [sym_logical_or_expression] = { + .visible = true, + .named = true, + }, + [sym_logical_and_expression] = { + .visible = true, + .named = true, + }, + [sym_equality_expression] = { + .visible = true, + .named = true, + }, + [sym_type_cast_expression] = { + .visible = true, + .named = true, + }, + [sym_type_test_expression] = { + .visible = true, + .named = true, + }, + [sym_relational_expression] = { + .visible = true, + .named = true, + }, + [sym_relational_operator] = { + .visible = true, + .named = true, + }, + [sym_bitwise_or_expression] = { + .visible = true, + .named = true, + }, + [sym_bitwise_xor_expression] = { + .visible = true, + .named = true, + }, + [sym_bitwise_and_expression] = { + .visible = true, + .named = true, + }, + [sym_shift_expression] = { + .visible = true, + .named = true, + }, + [sym_additive_expression] = { + .visible = true, + .named = true, + }, + [sym_multiplicative_expression] = { + .visible = true, + .named = true, + }, + [sym_bitwise_operator] = { + .visible = true, + .named = true, + }, + [sym__bitwise_operator] = { + .visible = false, + .named = true, + }, + [sym_shift_operator] = { + .visible = true, + .named = true, + }, + [sym__shift_operator] = { + .visible = false, + .named = true, + }, + [sym_additive_operator] = { + .visible = true, + .named = true, + }, + [sym_multiplicative_operator] = { + .visible = true, + .named = true, + }, + [sym__multiplicative_operator] = { + .visible = false, + .named = true, + }, + [sym__unary_expression] = { + .visible = false, + .named = true, + }, + [sym_unary_expression] = { + .visible = true, + .named = true, + }, + [sym__postfix_expression] = { + .visible = false, + .named = true, + }, + [sym_postfix_expression] = { + .visible = true, + .named = true, + }, + [sym_postfix_operator] = { + .visible = true, + .named = true, + }, + [sym_spread_element] = { + .visible = true, + .named = true, + }, + [sym_selector] = { + .visible = true, + .named = true, + }, + [sym_prefix_operator] = { + .visible = true, + .named = true, + }, + [sym_negation_operator] = { + .visible = true, + .named = true, + }, + [sym__exclamation_operator] = { + .visible = false, + .named = true, + }, + [sym_tilde_operator] = { + .visible = true, + .named = true, + }, + [sym_await_expression] = { + .visible = true, + .named = true, + }, + [sym_type_test] = { + .visible = true, + .named = true, + }, + [sym_is_operator] = { + .visible = true, + .named = true, + }, + [sym_type_cast] = { + .visible = true, + .named = true, + }, + [sym_as_operator] = { + .visible = true, + .named = true, + }, + [sym_new_expression] = { + .visible = true, + .named = true, + }, + [sym__dot_identifier] = { + .visible = false, + .named = true, + }, + [sym_const_object_expression] = { + .visible = true, + .named = true, + }, + [sym__primary] = { + .visible = false, + .named = true, + }, + [sym_parenthesized_expression] = { + .visible = true, + .named = true, + }, + [sym_constructor_invocation] = { + .visible = true, + .named = true, + }, + [sym_constructor_tearoff] = { + .visible = true, + .named = true, + }, + [sym_arguments] = { + .visible = true, + .named = true, + }, + [sym__argument_list] = { + .visible = false, + .named = true, + }, + [sym__any_argument] = { + .visible = false, + .named = true, + }, + [sym_argument] = { + .visible = true, + .named = true, + }, + [sym_named_argument] = { + .visible = true, + .named = true, + }, + [sym_cascade_section] = { + .visible = true, + .named = true, + }, + [sym__cascade_subsection] = { + .visible = false, + .named = true, + }, + [sym__cascade_assignment_section] = { + .visible = false, + .named = true, + }, + [sym_index_selector] = { + .visible = true, + .named = true, + }, + [sym_cascade_selector] = { + .visible = true, + .named = true, + }, + [sym_argument_part] = { + .visible = true, + .named = true, + }, + [sym_unconditional_assignable_selector] = { + .visible = true, + .named = true, + }, + [sym_conditional_assignable_selector] = { + .visible = true, + .named = true, + }, + [sym__assignable_selector] = { + .visible = false, + .named = true, + }, + [sym_type_arguments] = { + .visible = true, + .named = true, + }, + [sym__statement] = { + .visible = false, + .named = true, + .supertype = true, + }, + [sym_local_function_declaration] = { + .visible = true, + .named = true, + }, + [sym_block] = { + .visible = true, + .named = true, + }, + [sym_expression_statement] = { + .visible = true, + .named = true, + }, + [sym_assert_statement] = { + .visible = true, + .named = true, + }, + [sym_assertion] = { + .visible = true, + .named = true, + }, + [sym_assertion_arguments] = { + .visible = true, + .named = true, + }, + [sym_switch_statement] = { + .visible = true, + .named = true, + }, + [sym_switch_expression] = { + .visible = true, + .named = true, + }, + [sym_switch_expression_case] = { + .visible = true, + .named = true, + }, + [sym__guarded_pattern] = { + .visible = false, + .named = true, + }, + [sym__pattern] = { + .visible = false, + .named = true, + }, + [sym__logical_or_pattern] = { + .visible = false, + .named = true, + }, + [sym__logical_and_pattern] = { + .visible = false, + .named = true, + }, + [sym__relational_pattern] = { + .visible = false, + .named = true, + }, + [sym__unary_pattern] = { + .visible = false, + .named = true, + }, + [sym__primary_pattern] = { + .visible = false, + .named = true, + }, + [sym_cast_pattern] = { + .visible = true, + .named = true, + }, + [sym_null_check_pattern] = { + .visible = true, + .named = true, + }, + [sym_null_assert_pattern] = { + .visible = true, + .named = true, + }, + [sym_constant_pattern] = { + .visible = true, + .named = true, + }, + [sym_variable_pattern] = { + .visible = true, + .named = true, + }, + [sym__parenthesized_pattern] = { + .visible = false, + .named = true, + }, + [sym_list_pattern] = { + .visible = true, + .named = true, + }, + [sym__list_pattern_element] = { + .visible = false, + .named = true, + }, + [sym_rest_pattern] = { + .visible = true, + .named = true, + }, + [sym_map_pattern] = { + .visible = true, + .named = true, + }, + [sym__map_pattern_entry] = { + .visible = false, + .named = true, + }, + [sym_record_pattern] = { + .visible = true, + .named = true, + }, + [sym__pattern_field] = { + .visible = false, + .named = true, + }, + [sym_object_pattern] = { + .visible = true, + .named = true, + }, + [sym_pattern_variable_declaration] = { + .visible = true, + .named = true, + }, + [sym__outer_pattern] = { + .visible = false, + .named = true, + }, + [sym_pattern_assignment] = { + .visible = true, + .named = true, + }, + [sym_switch_block] = { + .visible = true, + .named = true, + }, + [sym_switch_statement_case] = { + .visible = true, + .named = true, + }, + [sym_switch_statement_default] = { + .visible = true, + .named = true, + }, + [sym_do_statement] = { + .visible = true, + .named = true, + }, + [sym_break_statement] = { + .visible = true, + .named = true, + }, + [sym_continue_statement] = { + .visible = true, + .named = true, + }, + [sym_yield_statement] = { + .visible = true, + .named = true, + }, + [sym_yield_each_statement] = { + .visible = true, + .named = true, + }, + [sym_return_statement] = { + .visible = true, + .named = true, + }, + [sym_try_statement] = { + .visible = true, + .named = true, + }, + [sym__on_part] = { + .visible = false, + .named = true, + }, + [sym__try_head] = { + .visible = false, + .named = true, + }, + [sym_catch_clause] = { + .visible = true, + .named = true, + }, + [sym_catch_parameters] = { + .visible = true, + .named = true, + }, + [sym_finally_clause] = { + .visible = true, + .named = true, + }, + [sym_if_element] = { + .visible = true, + .named = true, + }, + [sym_if_statement] = { + .visible = true, + .named = true, + }, + [sym_while_statement] = { + .visible = true, + .named = true, + }, + [sym_for_statement] = { + .visible = true, + .named = true, + }, + [sym_for_loop_parts] = { + .visible = true, + .named = true, + }, + [sym__for_loop_parts] = { + .visible = false, + .named = true, + }, + [sym_for_element] = { + .visible = true, + .named = true, + }, + [sym_annotation] = { + .visible = true, + .named = true, + }, + [sym_import_or_export] = { + .visible = true, + .named = true, + }, + [sym_library_import] = { + .visible = true, + .named = true, + }, + [sym_library_export] = { + .visible = true, + .named = true, + }, + [sym_import_specification] = { + .visible = true, + .named = true, + }, + [sym_part_directive] = { + .visible = true, + .named = true, + }, + [sym_part_of_directive] = { + .visible = true, + .named = true, + }, + [sym_uri] = { + .visible = true, + .named = true, + }, + [sym_configurable_uri] = { + .visible = true, + .named = true, + }, + [sym_configuration_uri] = { + .visible = true, + .named = true, + }, + [sym_configuration_uri_condition] = { + .visible = true, + .named = true, + }, + [sym_uri_test] = { + .visible = true, + .named = true, + }, + [sym_combinator] = { + .visible = true, + .named = true, + }, + [sym__identifier_list] = { + .visible = false, + .named = true, + }, + [sym_enum_declaration] = { + .visible = true, + .named = true, + }, + [sym_enum_body] = { + .visible = true, + .named = true, + }, + [sym_enum_constant] = { + .visible = true, + .named = true, + }, + [sym_type_alias] = { + .visible = true, + .named = true, + }, + [sym__class_modifiers] = { + .visible = false, + .named = true, + }, + [sym__mixin_class_modifiers] = { + .visible = false, + .named = true, + }, + [sym_class_definition] = { + .visible = true, + .named = true, + }, + [sym_extension_declaration] = { + .visible = true, + .named = true, + }, + [sym_extension_type_declaration] = { + .visible = true, + .named = true, + }, + [sym_representation_declaration] = { + .visible = true, + .named = true, + }, + [sym__metadata] = { + .visible = false, + .named = true, + }, + [sym_type_parameters] = { + .visible = true, + .named = true, + }, + [sym_type_parameter] = { + .visible = true, + .named = true, + }, + [sym_type_bound] = { + .visible = true, + .named = true, + }, + [sym_superclass] = { + .visible = true, + .named = true, + }, + [sym_mixins] = { + .visible = true, + .named = true, + }, + [sym_mixin_application_class] = { + .visible = true, + .named = true, + }, + [sym_mixin_application] = { + .visible = true, + .named = true, + }, + [sym_mixin_declaration] = { + .visible = true, + .named = true, + }, + [sym_interfaces] = { + .visible = true, + .named = true, + }, + [sym_class_body] = { + .visible = true, + .named = true, + }, + [sym_extension_body] = { + .visible = true, + .named = true, + }, + [sym_getter_signature] = { + .visible = true, + .named = true, + }, + [sym_setter_signature] = { + .visible = true, + .named = true, + }, + [sym_method_signature] = { + .visible = true, + .named = true, + }, + [sym_declaration] = { + .visible = true, + .named = true, + }, + [sym_identifier_list] = { + .visible = true, + .named = true, + }, + [sym_initialized_identifier_list] = { + .visible = true, + .named = true, + }, + [sym_initialized_identifier] = { + .visible = true, + .named = true, + }, + [sym_static_final_declaration_list] = { + .visible = true, + .named = true, + }, + [sym_binary_operator] = { + .visible = true, + .named = true, + }, + [sym_operator_signature] = { + .visible = true, + .named = true, + }, + [sym_static_final_declaration] = { + .visible = true, + .named = true, + }, + [sym__external_and_static] = { + .visible = false, + .named = true, + }, + [sym__final_or_const] = { + .visible = false, + .named = true, + }, + [sym_initializers] = { + .visible = true, + .named = true, + }, + [sym_initializer_list_entry] = { + .visible = true, + .named = true, + }, + [sym_field_initializer] = { + .visible = true, + .named = true, + }, + [sym_factory_constructor_signature] = { + .visible = true, + .named = true, + }, + [sym_redirecting_factory_constructor_signature] = { + .visible = true, + .named = true, + }, + [sym_redirection] = { + .visible = true, + .named = true, + }, + [sym_constructor_signature] = { + .visible = true, + .named = true, + }, + [sym_constant_constructor_signature] = { + .visible = true, + .named = true, + }, + [sym_scoped_identifier] = { + .visible = true, + .named = true, + }, + [sym_initialized_variable_definition] = { + .visible = true, + .named = true, + }, + [sym__declared_identifier] = { + .visible = false, + .named = true, + }, + [sym__final_const_var_or_type] = { + .visible = false, + .named = true, + }, + [sym__type] = { + .visible = false, + .named = true, + }, + [sym__type_not_function] = { + .visible = false, + .named = true, + }, + [sym__type_not_void_not_function] = { + .visible = false, + .named = true, + }, + [sym_function_type] = { + .visible = true, + .named = true, + }, + [aux_sym__function_type_tails] = { + .visible = false, + .named = false, + }, + [sym__function_type_tail] = { + .visible = false, + .named = true, + }, + [sym_parameter_type_list] = { + .visible = true, + .named = true, + }, + [sym_normal_parameter_type] = { + .visible = true, + .named = true, + }, + [sym_optional_parameter_types] = { + .visible = true, + .named = true, + }, + [sym_optional_positional_parameter_types] = { + .visible = true, + .named = true, + }, + [sym_named_parameter_types] = { + .visible = true, + .named = true, + }, + [sym__named_parameter_type] = { + .visible = false, + .named = true, + }, + [sym__type_not_void] = { + .visible = false, + .named = true, + }, + [sym_record_type] = { + .visible = true, + .named = true, + }, + [sym_record_type_field] = { + .visible = true, + .named = true, + }, + [sym_record_type_named_field] = { + .visible = true, + .named = true, + }, + [sym__type_not_void_list] = { + .visible = false, + .named = true, + }, + [sym__type_name] = { + .visible = false, + .named = true, + }, + [sym__type_dot_identifier] = { + .visible = false, + .named = true, + }, + [sym_typed_identifier] = { + .visible = true, + .named = true, + }, + [sym_nullable_type] = { + .visible = true, + .named = true, + }, + [sym_nullable_selector] = { + .visible = true, + .named = true, + }, + [sym__var_or_type] = { + .visible = false, + .named = true, + }, + [sym__final_var_or_type] = { + .visible = false, + .named = true, + }, + [sym_inferred_type] = { + .visible = true, + .named = true, + }, + [sym_function_body] = { + .visible = true, + .named = true, + }, + [sym_function_expression_body] = { + .visible = true, + .named = true, + }, + [sym_function_signature] = { + .visible = true, + .named = true, + }, + [sym__formal_parameter_part] = { + .visible = false, + .named = true, + }, + [sym_formal_parameter_list] = { + .visible = true, + .named = true, + }, + [sym__strict_formal_parameter_list] = { + .visible = false, + .named = true, + }, + [sym__normal_formal_parameters] = { + .visible = false, + .named = true, + }, + [sym_optional_formal_parameters] = { + .visible = true, + .named = true, + }, + [sym__optional_postional_formal_parameters] = { + .visible = false, + .named = true, + }, + [sym__named_formal_parameters] = { + .visible = false, + .named = true, + }, + [sym_formal_parameter] = { + .visible = true, + .named = true, + }, + [sym__default_formal_parameter] = { + .visible = false, + .named = true, + }, + [sym__default_named_parameter] = { + .visible = false, + .named = true, + }, + [sym__normal_formal_parameter] = { + .visible = false, + .named = true, + }, + [sym__function_formal_parameter] = { + .visible = false, + .named = true, + }, + [sym__simple_formal_parameter] = { + .visible = false, + .named = true, + }, + [sym_super_formal_parameter] = { + .visible = true, + .named = true, + }, + [sym_constructor_param] = { + .visible = true, + .named = true, + }, + [sym_local_variable_declaration] = { + .visible = true, + .named = true, + }, + [sym_script_tag] = { + .visible = true, + .named = true, + }, + [sym_library_name] = { + .visible = true, + .named = true, + }, + [sym_dotted_identifier_list] = { + .visible = true, + .named = true, + }, + [sym__identifier_or_new] = { + .visible = false, + .named = true, + }, + [sym_qualified] = { + .visible = true, + .named = true, + }, + [sym__as] = { + .visible = false, + .named = true, + }, + [sym_case_builtin] = { + .visible = true, + .named = true, + }, + [sym__covariant] = { + .visible = false, + .named = true, + }, + [sym__deferred] = { + .visible = false, + .named = true, + }, + [sym__export] = { + .visible = false, + .named = true, + }, + [sym__external] = { + .visible = false, + .named = true, + }, + [sym__factory] = { + .visible = false, + .named = true, + }, + [sym__function_builtin_identifier] = { + .visible = false, + .named = true, + }, + [sym__get] = { + .visible = false, + .named = true, + }, + [sym__native] = { + .visible = false, + .named = true, + }, + [sym__implements] = { + .visible = false, + .named = true, + }, + [sym__import] = { + .visible = false, + .named = true, + }, + [sym_interface] = { + .visible = true, + .named = true, + }, + [sym_base] = { + .visible = true, + .named = true, + }, + [sym_abstract] = { + .visible = true, + .named = true, + }, + [sym_sealed] = { + .visible = true, + .named = true, + }, + [sym__operator] = { + .visible = false, + .named = true, + }, + [sym_mixin] = { + .visible = true, + .named = true, + }, + [sym__required] = { + .visible = false, + .named = true, + }, + [sym__set] = { + .visible = false, + .named = true, + }, + [sym__static] = { + .visible = false, + .named = true, + }, + [sym__typedef] = { + .visible = false, + .named = true, + }, + [sym__new_builtin] = { + .visible = false, + .named = true, + }, + [sym_logical_and_operator] = { + .visible = true, + .named = true, + }, + [sym_logical_or_operator] = { + .visible = true, + .named = true, + }, + [sym_final_builtin] = { + .visible = true, + .named = true, + }, + [sym__late_builtin] = { + .visible = false, + .named = true, + }, + [sym__external_builtin] = { + .visible = false, + .named = true, + }, + [sym_this] = { + .visible = true, + .named = true, + }, + [sym_super] = { + .visible = true, + .named = true, + }, + [sym_label] = { + .visible = true, + .named = true, + }, + [sym__semicolon] = { + .visible = false, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [sym_documentation_comment] = { + .visible = true, + .named = true, + }, + [aux_sym_program_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_program_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_program_repeat3] = { + .visible = false, + .named = false, + }, + [aux_sym_program_repeat4] = { + .visible = false, + .named = false, + }, + [aux_sym_string_literal_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__string_literal_double_quotes_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__string_literal_single_quotes_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__string_literal_double_quotes_multiple_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__string_literal_single_quotes_multiple_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__raw_string_literal_double_quotes_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__raw_string_literal_single_quotes_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__raw_string_literal_double_quotes_multiple_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__raw_string_literal_single_quotes_multiple_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_list_literal_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__record_literal_no_const_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__assignable_selector_part_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_logical_or_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_logical_and_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_bitwise_or_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_bitwise_xor_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_bitwise_and_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_shift_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_additive_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_multiplicative_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__argument_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_cascade_section_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_cascade_section_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_type_arguments_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_switch_expression_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__logical_or_pattern_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__logical_and_pattern_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_list_pattern_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_map_pattern_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_record_pattern_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_switch_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_switch_statement_case_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_try_statement_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__for_loop_parts_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__for_loop_parts_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_library_export_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_configurable_uri_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__identifier_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_enum_body_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_enum_body_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym__metadata_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_type_parameters_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_extension_body_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_initialized_identifier_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_static_final_declaration_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_initializers_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_factory_constructor_signature_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_parameter_type_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_named_parameter_types_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_record_type_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_record_type_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym__type_not_void_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__normal_formal_parameters_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__optional_postional_formal_parameters_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__named_formal_parameters_repeat1] = { + .visible = false, + .named = false, + }, + [alias_sym_type_identifier] = { + .visible = true, + .named = true, + }, +}; + +enum ts_field_identifiers { + field_alternative = 1, + field_body = 2, + field_class = 3, + field_condition = 4, + field_consequence = 5, + field_first = 6, + field_init = 7, + field_interfaces = 8, + field_key = 9, + field_left = 10, + field_name = 11, + field_operator = 12, + field_parameters = 13, + field_representation = 14, + field_right = 15, + field_scope = 16, + field_second = 17, + field_superclass = 18, + field_type = 19, + field_type_parameters = 20, + field_update = 21, + field_value = 22, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_alternative] = "alternative", + [field_body] = "body", + [field_class] = "class", + [field_condition] = "condition", + [field_consequence] = "consequence", + [field_first] = "first", + [field_init] = "init", + [field_interfaces] = "interfaces", + [field_key] = "key", + [field_left] = "left", + [field_name] = "name", + [field_operator] = "operator", + [field_parameters] = "parameters", + [field_representation] = "representation", + [field_right] = "right", + [field_scope] = "scope", + [field_second] = "second", + [field_superclass] = "superclass", + [field_type] = "type", + [field_type_parameters] = "type_parameters", + [field_update] = "update", + [field_value] = "value", +}; + +static const TSMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [2] = {.index = 0, .length = 1}, + [3] = {.index = 1, .length = 1}, + [4] = {.index = 1, .length = 1}, + [5] = {.index = 2, .length = 2}, + [6] = {.index = 4, .length = 1}, + [8] = {.index = 5, .length = 1}, + [10] = {.index = 6, .length = 1}, + [11] = {.index = 0, .length = 1}, + [12] = {.index = 7, .length = 2}, + [13] = {.index = 9, .length = 2}, + [14] = {.index = 11, .length = 2}, + [15] = {.index = 13, .length = 1}, + [16] = {.index = 14, .length = 3}, + [17] = {.index = 17, .length = 3}, + [18] = {.index = 20, .length = 3}, + [19] = {.index = 23, .length = 2}, + [20] = {.index = 25, .length = 1}, + [21] = {.index = 26, .length = 2}, + [22] = {.index = 28, .length = 2}, + [23] = {.index = 30, .length = 2}, + [24] = {.index = 32, .length = 3}, + [25] = {.index = 35, .length = 3}, + [26] = {.index = 38, .length = 3}, + [27] = {.index = 41, .length = 2}, + [28] = {.index = 43, .length = 4}, + [29] = {.index = 47, .length = 4}, + [30] = {.index = 51, .length = 4}, + [31] = {.index = 55, .length = 2}, + [32] = {.index = 57, .length = 2}, + [33] = {.index = 59, .length = 3}, + [34] = {.index = 62, .length = 3}, + [35] = {.index = 65, .length = 3}, + [36] = {.index = 68, .length = 2}, + [37] = {.index = 70, .length = 1}, + [38] = {.index = 71, .length = 1}, + [39] = {.index = 72, .length = 2}, + [40] = {.index = 74, .length = 3}, + [41] = {.index = 77, .length = 2}, + [42] = {.index = 79, .length = 2}, + [43] = {.index = 81, .length = 3}, + [44] = {.index = 84, .length = 4}, + [45] = {.index = 88, .length = 4}, + [46] = {.index = 92, .length = 4}, + [47] = {.index = 96, .length = 1}, + [48] = {.index = 97, .length = 5}, + [49] = {.index = 102, .length = 2}, + [50] = {.index = 104, .length = 3}, + [51] = {.index = 107, .length = 3}, + [52] = {.index = 110, .length = 4}, + [53] = {.index = 114, .length = 4}, + [54] = {.index = 118, .length = 4}, + [55] = {.index = 122, .length = 2}, + [56] = {.index = 124, .length = 1}, + [57] = {.index = 125, .length = 1}, + [58] = {.index = 126, .length = 5}, + [59] = {.index = 131, .length = 1}, + [60] = {.index = 132, .length = 1}, + [61] = {.index = 133, .length = 4}, + [62] = {.index = 137, .length = 4}, + [63] = {.index = 141, .length = 2}, + [64] = {.index = 143, .length = 5}, + [65] = {.index = 148, .length = 4}, + [66] = {.index = 152, .length = 2}, + [67] = {.index = 154, .length = 3}, + [68] = {.index = 157, .length = 4}, + [69] = {.index = 161, .length = 5}, + [70] = {.index = 166, .length = 4}, + [71] = {.index = 170, .length = 2}, + [72] = {.index = 172, .length = 1}, + [73] = {.index = 173, .length = 1}, + [74] = {.index = 174, .length = 1}, + [75] = {.index = 175, .length = 2}, + [76] = {.index = 177, .length = 2}, + [77] = {.index = 179, .length = 2}, + [78] = {.index = 181, .length = 2}, + [79] = {.index = 183, .length = 1}, + [80] = {.index = 184, .length = 2}, + [81] = {.index = 186, .length = 1}, + [82] = {.index = 187, .length = 2}, + [83] = {.index = 189, .length = 5}, + [84] = {.index = 194, .length = 2}, + [85] = {.index = 196, .length = 4}, + [86] = {.index = 200, .length = 4}, + [87] = {.index = 204, .length = 5}, + [88] = {.index = 209, .length = 2}, + [89] = {.index = 211, .length = 3}, + [90] = {.index = 214, .length = 2}, + [91] = {.index = 216, .length = 2}, + [92] = {.index = 218, .length = 1}, + [93] = {.index = 219, .length = 3}, + [94] = {.index = 222, .length = 3}, + [95] = {.index = 225, .length = 2}, + [96] = {.index = 227, .length = 2}, + [97] = {.index = 229, .length = 2}, + [98] = {.index = 231, .length = 2}, + [99] = {.index = 233, .length = 5}, + [100] = {.index = 238, .length = 6}, + [101] = {.index = 244, .length = 2}, + [102] = {.index = 246, .length = 1}, + [103] = {.index = 247, .length = 3}, + [104] = {.index = 250, .length = 3}, + [105] = {.index = 253, .length = 3}, + [106] = {.index = 256, .length = 3}, + [107] = {.index = 259, .length = 4}, + [108] = {.index = 263, .length = 3}, + [109] = {.index = 266, .length = 2}, + [110] = {.index = 268, .length = 4}, + [111] = {.index = 272, .length = 4}, + [112] = {.index = 276, .length = 4}, + [113] = {.index = 280, .length = 2}, + [114] = {.index = 282, .length = 5}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_name, 1}, + [1] = + {field_name, 0}, + [2] = + {field_body, 2}, + {field_name, 1}, + [4] = + {field_name, 0, .inherited = true}, + [5] = + {field_body, 0, .inherited = true}, + [6] = + {field_name, 2}, + [7] = + {field_name, 2}, + {field_scope, 0}, + [9] = + {field_body, 3}, + {field_name, 1}, + [11] = + {field_body, 3}, + {field_class, 2}, + [13] = + {field_name, 1, .inherited = true}, + [14] = + {field_body, 3}, + {field_name, 1}, + {field_type_parameters, 2}, + [17] = + {field_body, 3}, + {field_name, 1}, + {field_superclass, 2}, + [20] = + {field_body, 3}, + {field_interfaces, 2}, + {field_name, 1}, + [23] = + {field_body, 3}, + {field_name, 2}, + [25] = + {field_body, 1}, + [26] = + {field_first, 0}, + {field_second, 1, .inherited = true}, + [28] = + {field_body, 1}, + {field_parameters, 0}, + [30] = + {field_body, 4}, + {field_name, 1}, + [32] = + {field_body, 4}, + {field_name, 2}, + {field_representation, 3}, + [35] = + {field_body, 4}, + {field_class, 3}, + {field_name, 1}, + [38] = + {field_body, 4}, + {field_class, 3}, + {field_type_parameters, 1}, + [41] = + {field_name, 0}, + {field_parameters, 1}, + [43] = + {field_body, 4}, + {field_name, 1}, + {field_superclass, 3}, + {field_type_parameters, 2}, + [47] = + {field_body, 4}, + {field_interfaces, 3}, + {field_name, 1}, + {field_type_parameters, 2}, + [51] = + {field_body, 4}, + {field_interfaces, 3}, + {field_name, 1}, + {field_superclass, 2}, + [55] = + {field_body, 4}, + {field_name, 2}, + [57] = + {field_body, 4}, + {field_class, 3}, + [59] = + {field_body, 4}, + {field_name, 2}, + {field_type_parameters, 3}, + [62] = + {field_body, 4}, + {field_name, 2}, + {field_superclass, 3}, + [65] = + {field_body, 4}, + {field_interfaces, 3}, + {field_name, 2}, + [68] = + {field_body, 2}, + {field_condition, 1}, + [70] = + {field_body, 2}, + [71] = + {field_second, 1}, + [72] = + {field_second, 0, .inherited = true}, + {field_second, 1, .inherited = true}, + [74] = + {field_left, 0}, + {field_operator, 1}, + {field_right, 2}, + [77] = + {field_name, 0, .inherited = true}, + {field_value, 2}, + [79] = + {field_body, 5}, + {field_name, 1}, + [81] = + {field_body, 5}, + {field_name, 3}, + {field_representation, 4}, + [84] = + {field_body, 5}, + {field_interfaces, 4}, + {field_name, 2}, + {field_representation, 3}, + [88] = + {field_body, 5}, + {field_name, 2}, + {field_representation, 4}, + {field_type_parameters, 3}, + [92] = + {field_body, 5}, + {field_class, 4}, + {field_name, 1}, + {field_type_parameters, 2}, + [96] = + {field_name, 3}, + [97] = + {field_body, 5}, + {field_interfaces, 4}, + {field_name, 1}, + {field_superclass, 3}, + {field_type_parameters, 2}, + [102] = + {field_body, 5}, + {field_name, 2}, + [104] = + {field_body, 5}, + {field_class, 4}, + {field_name, 2}, + [107] = + {field_body, 5}, + {field_class, 4}, + {field_type_parameters, 2}, + [110] = + {field_body, 5}, + {field_name, 2}, + {field_superclass, 4}, + {field_type_parameters, 3}, + [114] = + {field_body, 5}, + {field_interfaces, 4}, + {field_name, 2}, + {field_type_parameters, 3}, + [118] = + {field_body, 5}, + {field_interfaces, 4}, + {field_name, 2}, + {field_superclass, 3}, + [122] = + {field_key, 0}, + {field_value, 2}, + [124] = + {field_body, 3}, + [125] = + {field_condition, 0}, + [126] = + {field_condition, 1, .inherited = true}, + {field_init, 1, .inherited = true}, + {field_name, 1, .inherited = true}, + {field_update, 1, .inherited = true}, + {field_value, 1, .inherited = true}, + [131] = + {field_init, 0}, + [132] = + {field_update, 1}, + [133] = + {field_body, 6}, + {field_interfaces, 5}, + {field_name, 3}, + {field_representation, 4}, + [137] = + {field_body, 6}, + {field_name, 3}, + {field_representation, 5}, + {field_type_parameters, 4}, + [141] = + {field_name, 2}, + {field_type, 1}, + [143] = + {field_body, 6}, + {field_interfaces, 5}, + {field_name, 2}, + {field_representation, 4}, + {field_type_parameters, 3}, + [148] = + {field_name, 0}, + {field_name, 1}, + {field_name, 2}, + {field_parameters, 3}, + [152] = + {field_body, 6}, + {field_name, 2}, + [154] = + {field_body, 6}, + {field_name, 4}, + {field_representation, 5}, + [157] = + {field_body, 6}, + {field_class, 5}, + {field_name, 2}, + {field_type_parameters, 3}, + [161] = + {field_body, 6}, + {field_interfaces, 5}, + {field_name, 2}, + {field_superclass, 4}, + {field_type_parameters, 3}, + [166] = + {field_body, 2}, + {field_body, 3}, + {field_body, 4}, + {field_condition, 1}, + [170] = + {field_body, 1}, + {field_condition, 3}, + [172] = + {field_consequence, 4}, + [173] = + {field_value, 2}, + [174] = + {field_init, 1}, + [175] = + {field_condition, 0}, + {field_update, 2}, + [177] = + {field_init, 0, .inherited = true}, + {field_init, 1, .inherited = true}, + [179] = + {field_condition, 1}, + {field_init, 0}, + [181] = + {field_init, 0}, + {field_update, 2}, + [183] = + {field_condition, 1}, + [184] = + {field_update, 1}, + {field_update, 2, .inherited = true}, + [186] = + {field_update, 2}, + [187] = + {field_alternative, 4}, + {field_consequence, 2}, + [189] = + {field_body, 7}, + {field_interfaces, 6}, + {field_name, 3}, + {field_representation, 5}, + {field_type_parameters, 4}, + [194] = + {field_name, 3}, + {field_type, 2}, + [196] = + {field_body, 7}, + {field_interfaces, 6}, + {field_name, 4}, + {field_representation, 5}, + [200] = + {field_body, 7}, + {field_name, 4}, + {field_representation, 6}, + {field_type_parameters, 5}, + [204] = + {field_body, 2}, + {field_body, 3}, + {field_body, 4}, + {field_body, 5}, + {field_condition, 1}, + [209] = + {field_condition, 2}, + {field_init, 0}, + [211] = + {field_condition, 0}, + {field_update, 2}, + {field_update, 3, .inherited = true}, + [214] = + {field_init, 0}, + {field_update, 3}, + [216] = + {field_init, 0}, + {field_init, 1, .inherited = true}, + [218] = + {field_value, 3}, + [219] = + {field_condition, 1}, + {field_init, 0}, + {field_update, 3}, + [222] = + {field_init, 0}, + {field_update, 2}, + {field_update, 3, .inherited = true}, + [225] = + {field_condition, 1}, + {field_update, 3}, + [227] = + {field_update, 0, .inherited = true}, + {field_update, 1, .inherited = true}, + [229] = + {field_update, 2}, + {field_update, 3, .inherited = true}, + [231] = + {field_name, 4}, + {field_type, 3}, + [233] = + {field_body, 8}, + {field_interfaces, 7}, + {field_name, 4}, + {field_representation, 6}, + {field_type_parameters, 5}, + [238] = + {field_body, 2}, + {field_body, 3}, + {field_body, 4}, + {field_body, 5}, + {field_body, 6}, + {field_condition, 1}, + [244] = + {field_alternative, 6}, + {field_consequence, 4}, + [246] = + {field_consequence, 6}, + [247] = + {field_condition, 2}, + {field_init, 0}, + {field_update, 4}, + [250] = + {field_init, 0}, + {field_update, 3}, + {field_update, 4, .inherited = true}, + [253] = + {field_condition, 3}, + {field_init, 0}, + {field_init, 1, .inherited = true}, + [256] = + {field_init, 0}, + {field_init, 1, .inherited = true}, + {field_update, 4}, + [259] = + {field_condition, 1}, + {field_init, 0}, + {field_update, 3}, + {field_update, 4, .inherited = true}, + [263] = + {field_condition, 1}, + {field_update, 3}, + {field_update, 4, .inherited = true}, + [266] = + {field_name, 5}, + {field_type, 4}, + [268] = + {field_condition, 2}, + {field_init, 0}, + {field_update, 4}, + {field_update, 5, .inherited = true}, + [272] = + {field_condition, 3}, + {field_init, 0}, + {field_init, 1, .inherited = true}, + {field_update, 5}, + [276] = + {field_init, 0}, + {field_init, 1, .inherited = true}, + {field_update, 4}, + {field_update, 5, .inherited = true}, + [280] = + {field_alternative, 8}, + {field_consequence, 6}, + [282] = + {field_condition, 3}, + {field_init, 0}, + {field_init, 1, .inherited = true}, + {field_update, 5}, + {field_update, 6, .inherited = true}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, + [1] = { + [0] = alias_sym_type_identifier, + }, + [4] = { + [0] = sym_identifier, + }, + [7] = { + [1] = alias_sym_type_identifier, + }, + [9] = { + [0] = sym_identifier, + }, + [11] = { + [1] = sym_identifier, + }, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + sym__get, 2, + sym__get, + sym_identifier, + sym__set, 2, + sym__set, + sym_identifier, + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 2, + [4] = 2, + [5] = 5, + [6] = 6, + [7] = 7, + [8] = 8, + [9] = 9, + [10] = 10, + [11] = 11, + [12] = 12, + [13] = 13, + [14] = 14, + [15] = 14, + [16] = 16, + [17] = 17, + [18] = 17, + [19] = 19, + [20] = 20, + [21] = 21, + [22] = 22, + [23] = 16, + [24] = 17, + [25] = 16, + [26] = 17, + [27] = 16, + [28] = 17, + [29] = 16, + [30] = 30, + [31] = 31, + [32] = 32, + [33] = 33, + [34] = 34, + [35] = 35, + [36] = 32, + [37] = 35, + [38] = 38, + [39] = 39, + [40] = 40, + [41] = 41, + [42] = 38, + [43] = 39, + [44] = 40, + [45] = 41, + [46] = 34, + [47] = 33, + [48] = 48, + [49] = 49, + [50] = 49, + [51] = 51, + [52] = 52, + [53] = 52, + [54] = 51, + [55] = 51, + [56] = 52, + [57] = 57, + [58] = 57, + [59] = 57, + [60] = 57, + [61] = 61, + [62] = 62, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 66, + [67] = 67, + [68] = 67, + [69] = 67, + [70] = 67, + [71] = 71, + [72] = 72, + [73] = 73, + [74] = 73, + [75] = 72, + [76] = 73, + [77] = 72, + [78] = 78, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 78, + [90] = 90, + [91] = 91, + [92] = 92, + [93] = 93, + [94] = 94, + [95] = 95, + [96] = 96, + [97] = 97, + [98] = 98, + [99] = 99, + [100] = 100, + [101] = 101, + [102] = 102, + [103] = 99, + [104] = 100, + [105] = 105, + [106] = 86, + [107] = 95, + [108] = 108, + [109] = 85, + [110] = 96, + [111] = 111, + [112] = 101, + [113] = 102, + [114] = 114, + [115] = 115, + [116] = 115, + [117] = 79, + [118] = 80, + [119] = 88, + [120] = 78, + [121] = 99, + [122] = 100, + [123] = 86, + [124] = 95, + [125] = 85, + [126] = 96, + [127] = 101, + [128] = 102, + [129] = 105, + [130] = 115, + [131] = 79, + [132] = 80, + [133] = 88, + [134] = 78, + [135] = 99, + [136] = 100, + [137] = 86, + [138] = 95, + [139] = 85, + [140] = 96, + [141] = 101, + [142] = 102, + [143] = 105, + [144] = 115, + [145] = 79, + [146] = 80, + [147] = 88, + [148] = 148, + [149] = 105, + [150] = 150, + [151] = 151, + [152] = 152, + [153] = 153, + [154] = 154, + [155] = 155, + [156] = 156, + [157] = 157, + [158] = 158, + [159] = 159, + [160] = 160, + [161] = 161, + [162] = 161, + [163] = 161, + [164] = 161, + [165] = 161, + [166] = 161, + [167] = 161, + [168] = 161, + [169] = 161, + [170] = 170, + [171] = 171, + [172] = 172, + [173] = 173, + [174] = 174, + [175] = 175, + [176] = 176, + [177] = 177, + [178] = 177, + [179] = 179, + [180] = 180, + [181] = 181, + [182] = 177, + [183] = 177, + [184] = 184, + [185] = 185, + [186] = 186, + [187] = 187, + [188] = 188, + [189] = 189, + [190] = 190, + [191] = 191, + [192] = 192, + [193] = 193, + [194] = 194, + [195] = 195, + [196] = 196, + [197] = 197, + [198] = 198, + [199] = 199, + [200] = 200, + [201] = 201, + [202] = 202, + [203] = 203, + [204] = 204, + [205] = 205, + [206] = 206, + [207] = 207, + [208] = 208, + [209] = 209, + [210] = 210, + [211] = 211, + [212] = 212, + [213] = 213, + [214] = 206, + [215] = 215, + [216] = 204, + [217] = 207, + [218] = 209, + [219] = 219, + [220] = 220, + [221] = 204, + [222] = 207, + [223] = 209, + [224] = 220, + [225] = 204, + [226] = 207, + [227] = 209, + [228] = 220, + [229] = 204, + [230] = 207, + [231] = 231, + [232] = 232, + [233] = 206, + [234] = 234, + [235] = 235, + [236] = 236, + [237] = 237, + [238] = 238, + [239] = 220, + [240] = 240, + [241] = 206, + [242] = 242, + [243] = 243, + [244] = 235, + [245] = 245, + [246] = 246, + [247] = 247, + [248] = 248, + [249] = 206, + [250] = 201, + [251] = 251, + [252] = 252, + [253] = 253, + [254] = 237, + [255] = 242, + [256] = 205, + [257] = 237, + [258] = 242, + [259] = 259, + [260] = 205, + [261] = 237, + [262] = 242, + [263] = 263, + [264] = 205, + [265] = 205, + [266] = 205, + [267] = 205, + [268] = 205, + [269] = 205, + [270] = 205, + [271] = 205, + [272] = 205, + [273] = 205, + [274] = 274, + [275] = 275, + [276] = 276, + [277] = 277, + [278] = 274, + [279] = 275, + [280] = 276, + [281] = 277, + [282] = 275, + [283] = 283, + [284] = 277, + [285] = 274, + [286] = 283, + [287] = 275, + [288] = 276, + [289] = 276, + [290] = 274, + [291] = 283, + [292] = 276, + [293] = 277, + [294] = 274, + [295] = 277, + [296] = 283, + [297] = 275, + [298] = 283, + [299] = 275, + [300] = 283, + [301] = 277, + [302] = 274, + [303] = 277, + [304] = 275, + [305] = 277, + [306] = 277, + [307] = 275, + [308] = 275, + [309] = 309, + [310] = 310, + [311] = 311, + [312] = 312, + [313] = 313, + [314] = 314, + [315] = 315, + [316] = 309, + [317] = 317, + [318] = 318, + [319] = 319, + [320] = 320, + [321] = 321, + [322] = 313, + [323] = 310, + [324] = 311, + [325] = 312, + [326] = 314, + [327] = 309, + [328] = 328, + [329] = 317, + [330] = 318, + [331] = 319, + [332] = 320, + [333] = 321, + [334] = 313, + [335] = 310, + [336] = 311, + [337] = 312, + [338] = 310, + [339] = 311, + [340] = 312, + [341] = 309, + [342] = 317, + [343] = 315, + [344] = 318, + [345] = 319, + [346] = 320, + [347] = 320, + [348] = 321, + [349] = 317, + [350] = 318, + [351] = 313, + [352] = 310, + [353] = 319, + [354] = 311, + [355] = 312, + [356] = 309, + [357] = 317, + [358] = 318, + [359] = 319, + [360] = 320, + [361] = 309, + [362] = 317, + [363] = 318, + [364] = 319, + [365] = 320, + [366] = 321, + [367] = 313, + [368] = 310, + [369] = 311, + [370] = 312, + [371] = 321, + [372] = 313, + [373] = 321, + [374] = 374, + [375] = 375, + [376] = 376, + [377] = 377, + [378] = 378, + [379] = 379, + [380] = 377, + [381] = 381, + [382] = 381, + [383] = 383, + [384] = 381, + [385] = 385, + [386] = 386, + [387] = 387, + [388] = 388, + [389] = 386, + [390] = 390, + [391] = 381, + [392] = 392, + [393] = 386, + [394] = 394, + [395] = 390, + [396] = 390, + [397] = 381, + [398] = 388, + [399] = 386, + [400] = 390, + [401] = 390, + [402] = 386, + [403] = 403, + [404] = 404, + [405] = 403, + [406] = 406, + [407] = 407, + [408] = 408, + [409] = 409, + [410] = 410, + [411] = 408, + [412] = 408, + [413] = 403, + [414] = 403, + [415] = 415, + [416] = 408, + [417] = 417, + [418] = 418, + [419] = 418, + [420] = 420, + [421] = 421, + [422] = 422, + [423] = 418, + [424] = 424, + [425] = 418, + [426] = 426, + [427] = 427, + [428] = 428, + [429] = 429, + [430] = 430, + [431] = 428, + [432] = 432, + [433] = 433, + [434] = 434, + [435] = 435, + [436] = 436, + [437] = 437, + [438] = 438, + [439] = 439, + [440] = 440, + [441] = 441, + [442] = 442, + [443] = 443, + [444] = 444, + [445] = 445, + [446] = 446, + [447] = 447, + [448] = 448, + [449] = 449, + [450] = 450, + [451] = 450, + [452] = 450, + [453] = 450, + [454] = 450, + [455] = 455, + [456] = 456, + [457] = 457, + [458] = 458, + [459] = 459, + [460] = 460, + [461] = 461, + [462] = 462, + [463] = 463, + [464] = 464, + [465] = 465, + [466] = 460, + [467] = 467, + [468] = 468, + [469] = 459, + [470] = 470, + [471] = 471, + [472] = 472, + [473] = 473, + [474] = 474, + [475] = 475, + [476] = 476, + [477] = 477, + [478] = 478, + [479] = 479, + [480] = 480, + [481] = 481, + [482] = 482, + [483] = 483, + [484] = 484, + [485] = 470, + [486] = 486, + [487] = 471, + [488] = 444, + [489] = 489, + [490] = 490, + [491] = 491, + [492] = 443, + [493] = 493, + [494] = 494, + [495] = 495, + [496] = 496, + [497] = 497, + [498] = 498, + [499] = 499, + [500] = 500, + [501] = 501, + [502] = 502, + [503] = 503, + [504] = 504, + [505] = 505, + [506] = 506, + [507] = 507, + [508] = 508, + [509] = 509, + [510] = 483, + [511] = 482, + [512] = 512, + [513] = 513, + [514] = 482, + [515] = 508, + [516] = 516, + [517] = 517, + [518] = 518, + [519] = 519, + [520] = 520, + [521] = 521, + [522] = 522, + [523] = 523, + [524] = 524, + [525] = 525, + [526] = 526, + [527] = 527, + [528] = 528, + [529] = 529, + [530] = 530, + [531] = 531, + [532] = 532, + [533] = 533, + [534] = 534, + [535] = 535, + [536] = 525, + [537] = 537, + [538] = 538, + [539] = 539, + [540] = 540, + [541] = 541, + [542] = 542, + [543] = 543, + [544] = 544, + [545] = 545, + [546] = 546, + [547] = 547, + [548] = 548, + [549] = 549, + [550] = 550, + [551] = 551, + [552] = 552, + [553] = 553, + [554] = 554, + [555] = 555, + [556] = 507, + [557] = 494, + [558] = 558, + [559] = 559, + [560] = 495, + [561] = 561, + [562] = 562, + [563] = 504, + [564] = 499, + [565] = 500, + [566] = 502, + [567] = 503, + [568] = 505, + [569] = 506, + [570] = 501, + [571] = 498, + [572] = 572, + [573] = 496, + [574] = 574, + [575] = 497, + [576] = 576, + [577] = 577, + [578] = 574, + [579] = 579, + [580] = 580, + [581] = 581, + [582] = 582, + [583] = 583, + [584] = 584, + [585] = 585, + [586] = 586, + [587] = 587, + [588] = 588, + [589] = 589, + [590] = 478, + [591] = 591, + [592] = 555, + [593] = 593, + [594] = 475, + [595] = 595, + [596] = 596, + [597] = 597, + [598] = 598, + [599] = 599, + [600] = 600, + [601] = 558, + [602] = 552, + [603] = 554, + [604] = 604, + [605] = 525, + [606] = 525, + [607] = 607, + [608] = 608, + [609] = 576, + [610] = 562, + [611] = 559, + [612] = 558, + [613] = 552, + [614] = 554, + [615] = 555, + [616] = 574, + [617] = 617, + [618] = 618, + [619] = 619, + [620] = 620, + [621] = 621, + [622] = 622, + [623] = 623, + [624] = 617, + [625] = 625, + [626] = 626, + [627] = 627, + [628] = 628, + [629] = 629, + [630] = 478, + [631] = 475, + [632] = 632, + [633] = 633, + [634] = 634, + [635] = 635, + [636] = 636, + [637] = 637, + [638] = 638, + [639] = 587, + [640] = 558, + [641] = 552, + [642] = 642, + [643] = 643, + [644] = 586, + [645] = 554, + [646] = 638, + [647] = 617, + [648] = 642, + [649] = 555, + [650] = 574, + [651] = 651, + [652] = 525, + [653] = 600, + [654] = 643, + [655] = 588, + [656] = 525, + [657] = 582, + [658] = 593, + [659] = 584, + [660] = 599, + [661] = 574, + [662] = 576, + [663] = 638, + [664] = 562, + [665] = 665, + [666] = 666, + [667] = 667, + [668] = 666, + [669] = 554, + [670] = 555, + [671] = 638, + [672] = 672, + [673] = 559, + [674] = 482, + [675] = 665, + [676] = 558, + [677] = 525, + [678] = 552, + [679] = 665, + [680] = 665, + [681] = 642, + [682] = 682, + [683] = 506, + [684] = 684, + [685] = 685, + [686] = 496, + [687] = 687, + [688] = 501, + [689] = 638, + [690] = 638, + [691] = 638, + [692] = 504, + [693] = 503, + [694] = 643, + [695] = 695, + [696] = 505, + [697] = 498, + [698] = 638, + [699] = 643, + [700] = 497, + [701] = 701, + [702] = 499, + [703] = 500, + [704] = 502, + [705] = 665, + [706] = 706, + [707] = 666, + [708] = 665, + [709] = 666, + [710] = 665, + [711] = 665, + [712] = 667, + [713] = 503, + [714] = 501, + [715] = 502, + [716] = 638, + [717] = 643, + [718] = 498, + [719] = 505, + [720] = 504, + [721] = 499, + [722] = 482, + [723] = 496, + [724] = 497, + [725] = 500, + [726] = 638, + [727] = 643, + [728] = 506, + [729] = 632, + [730] = 627, + [731] = 628, + [732] = 629, + [733] = 618, + [734] = 619, + [735] = 665, + [736] = 666, + [737] = 633, + [738] = 634, + [739] = 635, + [740] = 607, + [741] = 636, + [742] = 637, + [743] = 608, + [744] = 665, + [745] = 666, + [746] = 667, + [747] = 622, + [748] = 748, + [749] = 623, + [750] = 625, + [751] = 626, + [752] = 502, + [753] = 501, + [754] = 498, + [755] = 496, + [756] = 756, + [757] = 757, + [758] = 758, + [759] = 759, + [760] = 760, + [761] = 761, + [762] = 459, + [763] = 504, + [764] = 499, + [765] = 765, + [766] = 766, + [767] = 500, + [768] = 460, + [769] = 502, + [770] = 503, + [771] = 505, + [772] = 504, + [773] = 506, + [774] = 499, + [775] = 500, + [776] = 503, + [777] = 505, + [778] = 506, + [779] = 501, + [780] = 498, + [781] = 496, + [782] = 497, + [783] = 497, + [784] = 629, + [785] = 619, + [786] = 786, + [787] = 787, + [788] = 788, + [789] = 789, + [790] = 632, + [791] = 633, + [792] = 634, + [793] = 635, + [794] = 607, + [795] = 636, + [796] = 637, + [797] = 608, + [798] = 798, + [799] = 618, + [800] = 800, + [801] = 801, + [802] = 802, + [803] = 803, + [804] = 804, + [805] = 687, + [806] = 806, + [807] = 695, + [808] = 622, + [809] = 809, + [810] = 623, + [811] = 625, + [812] = 626, + [813] = 627, + [814] = 628, + [815] = 815, + [816] = 816, + [817] = 817, + [818] = 818, + [819] = 819, + [820] = 525, + [821] = 821, + [822] = 822, + [823] = 823, + [824] = 824, + [825] = 825, + [826] = 826, + [827] = 459, + [828] = 828, + [829] = 460, + [830] = 830, + [831] = 831, + [832] = 832, + [833] = 833, + [834] = 834, + [835] = 835, + [836] = 836, + [837] = 837, + [838] = 838, + [839] = 839, + [840] = 840, + [841] = 841, + [842] = 842, + [843] = 843, + [844] = 558, + [845] = 552, + [846] = 576, + [847] = 562, + [848] = 848, + [849] = 849, + [850] = 850, + [851] = 851, + [852] = 554, + [853] = 555, + [854] = 559, + [855] = 574, + [856] = 856, + [857] = 857, + [858] = 858, + [859] = 859, + [860] = 860, + [861] = 861, + [862] = 862, + [863] = 863, + [864] = 864, + [865] = 865, + [866] = 866, + [867] = 867, + [868] = 868, + [869] = 869, + [870] = 870, + [871] = 871, + [872] = 872, + [873] = 873, + [874] = 874, + [875] = 875, + [876] = 876, + [877] = 877, + [878] = 878, + [879] = 879, + [880] = 880, + [881] = 881, + [882] = 882, + [883] = 883, + [884] = 884, + [885] = 885, + [886] = 886, + [887] = 507, + [888] = 756, + [889] = 765, + [890] = 766, + [891] = 757, + [892] = 758, + [893] = 525, + [894] = 894, + [895] = 572, + [896] = 896, + [897] = 897, + [898] = 898, + [899] = 899, + [900] = 900, + [901] = 901, + [902] = 902, + [903] = 903, + [904] = 904, + [905] = 905, + [906] = 582, + [907] = 907, + [908] = 908, + [909] = 909, + [910] = 910, + [911] = 599, + [912] = 495, + [913] = 913, + [914] = 914, + [915] = 915, + [916] = 916, + [917] = 917, + [918] = 918, + [919] = 574, + [920] = 920, + [921] = 921, + [922] = 922, + [923] = 923, + [924] = 924, + [925] = 925, + [926] = 926, + [927] = 927, + [928] = 928, + [929] = 929, + [930] = 930, + [931] = 931, + [932] = 593, + [933] = 933, + [934] = 934, + [935] = 935, + [936] = 554, + [937] = 444, + [938] = 600, + [939] = 939, + [940] = 940, + [941] = 941, + [942] = 942, + [943] = 943, + [944] = 944, + [945] = 945, + [946] = 946, + [947] = 947, + [948] = 786, + [949] = 949, + [950] = 950, + [951] = 801, + [952] = 952, + [953] = 494, + [954] = 954, + [955] = 483, + [956] = 956, + [957] = 802, + [958] = 809, + [959] = 959, + [960] = 788, + [961] = 961, + [962] = 962, + [963] = 803, + [964] = 964, + [965] = 804, + [966] = 806, + [967] = 789, + [968] = 798, + [969] = 576, + [970] = 562, + [971] = 559, + [972] = 972, + [973] = 973, + [974] = 974, + [975] = 975, + [976] = 976, + [977] = 977, + [978] = 978, + [979] = 979, + [980] = 980, + [981] = 981, + [982] = 982, + [983] = 983, + [984] = 984, + [985] = 985, + [986] = 986, + [987] = 987, + [988] = 988, + [989] = 989, + [990] = 443, + [991] = 525, + [992] = 555, + [993] = 993, + [994] = 994, + [995] = 995, + [996] = 996, + [997] = 997, + [998] = 998, + [999] = 558, + [1000] = 552, + [1001] = 1001, + [1002] = 1002, + [1003] = 1003, + [1004] = 1004, + [1005] = 1005, + [1006] = 1006, + [1007] = 822, + [1008] = 816, + [1009] = 823, + [1010] = 817, + [1011] = 828, + [1012] = 1012, + [1013] = 821, + [1014] = 833, + [1015] = 525, + [1016] = 559, + [1017] = 818, + [1018] = 828, + [1019] = 832, + [1020] = 834, + [1021] = 835, + [1022] = 824, + [1023] = 826, + [1024] = 819, + [1025] = 576, + [1026] = 562, + [1027] = 849, + [1028] = 896, + [1029] = 886, + [1030] = 875, + [1031] = 877, + [1032] = 898, + [1033] = 470, + [1034] = 864, + [1035] = 1035, + [1036] = 576, + [1037] = 562, + [1038] = 559, + [1039] = 863, + [1040] = 897, + [1041] = 558, + [1042] = 552, + [1043] = 848, + [1044] = 554, + [1045] = 555, + [1046] = 878, + [1047] = 574, + [1048] = 879, + [1049] = 880, + [1050] = 525, + [1051] = 881, + [1052] = 525, + [1053] = 842, + [1054] = 850, + [1055] = 871, + [1056] = 882, + [1057] = 883, + [1058] = 839, + [1059] = 1059, + [1060] = 856, + [1061] = 840, + [1062] = 836, + [1063] = 884, + [1064] = 857, + [1065] = 858, + [1066] = 885, + [1067] = 859, + [1068] = 841, + [1069] = 837, + [1070] = 1070, + [1071] = 860, + [1072] = 872, + [1073] = 838, + [1074] = 861, + [1075] = 862, + [1076] = 899, + [1077] = 865, + [1078] = 1078, + [1079] = 843, + [1080] = 866, + [1081] = 471, + [1082] = 873, + [1083] = 867, + [1084] = 868, + [1085] = 988, + [1086] = 869, + [1087] = 874, + [1088] = 870, + [1089] = 851, + [1090] = 552, + [1091] = 786, + [1092] = 978, + [1093] = 994, + [1094] = 995, + [1095] = 996, + [1096] = 443, + [1097] = 998, + [1098] = 989, + [1099] = 933, + [1100] = 903, + [1101] = 907, + [1102] = 909, + [1103] = 910, + [1104] = 599, + [1105] = 993, + [1106] = 913, + [1107] = 914, + [1108] = 599, + [1109] = 916, + [1110] = 917, + [1111] = 952, + [1112] = 928, + [1113] = 1113, + [1114] = 929, + [1115] = 600, + [1116] = 954, + [1117] = 444, + [1118] = 600, + [1119] = 997, + [1120] = 976, + [1121] = 944, + [1122] = 949, + [1123] = 984, + [1124] = 985, + [1125] = 586, + [1126] = 964, + [1127] = 902, + [1128] = 904, + [1129] = 587, + [1130] = 979, + [1131] = 988, + [1132] = 918, + [1133] = 920, + [1134] = 930, + [1135] = 900, + [1136] = 588, + [1137] = 943, + [1138] = 525, + [1139] = 926, + [1140] = 927, + [1141] = 582, + [1142] = 558, + [1143] = 552, + [1144] = 931, + [1145] = 941, + [1146] = 554, + [1147] = 555, + [1148] = 593, + [1149] = 1001, + [1150] = 1002, + [1151] = 962, + [1152] = 905, + [1153] = 939, + [1154] = 1006, + [1155] = 908, + [1156] = 582, + [1157] = 940, + [1158] = 946, + [1159] = 599, + [1160] = 600, + [1161] = 576, + [1162] = 562, + [1163] = 559, + [1164] = 980, + [1165] = 987, + [1166] = 572, + [1167] = 1003, + [1168] = 1004, + [1169] = 558, + [1170] = 1005, + [1171] = 576, + [1172] = 562, + [1173] = 554, + [1174] = 555, + [1175] = 559, + [1176] = 574, + [1177] = 593, + [1178] = 915, + [1179] = 978, + [1180] = 959, + [1181] = 961, + [1182] = 922, + [1183] = 934, + [1184] = 942, + [1185] = 574, + [1186] = 921, + [1187] = 923, + [1188] = 924, + [1189] = 925, + [1190] = 935, + [1191] = 945, + [1192] = 947, + [1193] = 950, + [1194] = 956, + [1195] = 803, + [1196] = 584, + [1197] = 972, + [1198] = 974, + [1199] = 975, + [1200] = 977, + [1201] = 981, + [1202] = 809, + [1203] = 982, + [1204] = 901, + [1205] = 863, + [1206] = 558, + [1207] = 552, + [1208] = 554, + [1209] = 555, + [1210] = 576, + [1211] = 897, + [1212] = 559, + [1213] = 460, + [1214] = 459, + [1215] = 839, + [1216] = 837, + [1217] = 562, + [1218] = 886, + [1219] = 1219, + [1220] = 471, + [1221] = 838, + [1222] = 470, + [1223] = 574, + [1224] = 525, + [1225] = 1225, + [1226] = 1226, + [1227] = 898, + [1228] = 574, + [1229] = 920, + [1230] = 985, + [1231] = 930, + [1232] = 593, + [1233] = 921, + [1234] = 600, + [1235] = 933, + [1236] = 900, + [1237] = 925, + [1238] = 786, + [1239] = 977, + [1240] = 1006, + [1241] = 981, + [1242] = 982, + [1243] = 896, + [1244] = 757, + [1245] = 984, + [1246] = 915, + [1247] = 923, + [1248] = 935, + [1249] = 803, + [1250] = 576, + [1251] = 562, + [1252] = 1001, + [1253] = 994, + [1254] = 926, + [1255] = 599, + [1256] = 809, + [1257] = 945, + [1258] = 995, + [1259] = 1259, + [1260] = 1260, + [1261] = 962, + [1262] = 940, + [1263] = 946, + [1264] = 979, + [1265] = 959, + [1266] = 993, + [1267] = 559, + [1268] = 1268, + [1269] = 1269, + [1270] = 444, + [1271] = 961, + [1272] = 922, + [1273] = 934, + [1274] = 996, + [1275] = 758, + [1276] = 956, + [1277] = 980, + [1278] = 1278, + [1279] = 987, + [1280] = 1280, + [1281] = 1281, + [1282] = 572, + [1283] = 998, + [1284] = 1003, + [1285] = 988, + [1286] = 942, + [1287] = 902, + [1288] = 918, + [1289] = 1005, + [1290] = 1004, + [1291] = 1291, + [1292] = 1292, + [1293] = 972, + [1294] = 1294, + [1295] = 997, + [1296] = 901, + [1297] = 1297, + [1298] = 443, + [1299] = 947, + [1300] = 950, + [1301] = 989, + [1302] = 582, + [1303] = 1303, + [1304] = 558, + [1305] = 552, + [1306] = 924, + [1307] = 943, + [1308] = 974, + [1309] = 975, + [1310] = 554, + [1311] = 555, + [1312] = 864, + [1313] = 1313, + [1314] = 964, + [1315] = 804, + [1316] = 806, + [1317] = 928, + [1318] = 914, + [1319] = 929, + [1320] = 907, + [1321] = 910, + [1322] = 909, + [1323] = 789, + [1324] = 1324, + [1325] = 798, + [1326] = 388, + [1327] = 913, + [1328] = 756, + [1329] = 1329, + [1330] = 765, + [1331] = 766, + [1332] = 1332, + [1333] = 1324, + [1334] = 1324, + [1335] = 927, + [1336] = 1324, + [1337] = 1324, + [1338] = 1338, + [1339] = 802, + [1340] = 1338, + [1341] = 757, + [1342] = 758, + [1343] = 1343, + [1344] = 788, + [1345] = 1345, + [1346] = 1346, + [1347] = 1347, + [1348] = 1338, + [1349] = 786, + [1350] = 1350, + [1351] = 823, + [1352] = 786, + [1353] = 1338, + [1354] = 1354, + [1355] = 1338, + [1356] = 803, + [1357] = 1357, + [1358] = 1358, + [1359] = 1359, + [1360] = 1338, + [1361] = 1361, + [1362] = 1338, + [1363] = 1338, + [1364] = 809, + [1365] = 1338, + [1366] = 1338, + [1367] = 1338, + [1368] = 1338, + [1369] = 1358, + [1370] = 803, + [1371] = 1358, + [1372] = 1372, + [1373] = 801, + [1374] = 1374, + [1375] = 909, + [1376] = 835, + [1377] = 804, + [1378] = 1378, + [1379] = 822, + [1380] = 870, + [1381] = 756, + [1382] = 806, + [1383] = 765, + [1384] = 766, + [1385] = 471, + [1386] = 859, + [1387] = 978, + [1388] = 824, + [1389] = 826, + [1390] = 856, + [1391] = 928, + [1392] = 929, + [1393] = 1393, + [1394] = 907, + [1395] = 834, + [1396] = 816, + [1397] = 817, + [1398] = 910, + [1399] = 789, + [1400] = 1219, + [1401] = 964, + [1402] = 600, + [1403] = 913, + [1404] = 875, + [1405] = 914, + [1406] = 819, + [1407] = 599, + [1408] = 833, + [1409] = 818, + [1410] = 798, + [1411] = 1411, + [1412] = 832, + [1413] = 470, + [1414] = 927, + [1415] = 1415, + [1416] = 850, + [1417] = 1417, + [1418] = 884, + [1419] = 864, + [1420] = 899, + [1421] = 865, + [1422] = 866, + [1423] = 867, + [1424] = 802, + [1425] = 885, + [1426] = 868, + [1427] = 869, + [1428] = 880, + [1429] = 823, + [1430] = 881, + [1431] = 788, + [1432] = 877, + [1433] = 1343, + [1434] = 1374, + [1435] = 757, + [1436] = 1436, + [1437] = 801, + [1438] = 898, + [1439] = 848, + [1440] = 836, + [1441] = 871, + [1442] = 857, + [1443] = 872, + [1444] = 873, + [1445] = 858, + [1446] = 882, + [1447] = 874, + [1448] = 860, + [1449] = 842, + [1450] = 843, + [1451] = 896, + [1452] = 758, + [1453] = 861, + [1454] = 849, + [1455] = 840, + [1456] = 851, + [1457] = 883, + [1458] = 862, + [1459] = 879, + [1460] = 878, + [1461] = 841, + [1462] = 483, + [1463] = 826, + [1464] = 903, + [1465] = 834, + [1466] = 835, + [1467] = 856, + [1468] = 832, + [1469] = 909, + [1470] = 817, + [1471] = 816, + [1472] = 806, + [1473] = 904, + [1474] = 875, + [1475] = 819, + [1476] = 910, + [1477] = 833, + [1478] = 1332, + [1479] = 475, + [1480] = 917, + [1481] = 758, + [1482] = 905, + [1483] = 756, + [1484] = 1329, + [1485] = 789, + [1486] = 1002, + [1487] = 478, + [1488] = 931, + [1489] = 913, + [1490] = 914, + [1491] = 1491, + [1492] = 818, + [1493] = 765, + [1494] = 927, + [1495] = 944, + [1496] = 949, + [1497] = 907, + [1498] = 804, + [1499] = 859, + [1500] = 916, + [1501] = 798, + [1502] = 757, + [1503] = 941, + [1504] = 870, + [1505] = 978, + [1506] = 928, + [1507] = 929, + [1508] = 824, + [1509] = 964, + [1510] = 822, + [1511] = 766, + [1512] = 1313, + [1513] = 880, + [1514] = 899, + [1515] = 865, + [1516] = 866, + [1517] = 896, + [1518] = 867, + [1519] = 868, + [1520] = 898, + [1521] = 869, + [1522] = 864, + [1523] = 1523, + [1524] = 823, + [1525] = 848, + [1526] = 870, + [1527] = 871, + [1528] = 872, + [1529] = 873, + [1530] = 788, + [1531] = 874, + [1532] = 849, + [1533] = 850, + [1534] = 851, + [1535] = 875, + [1536] = 1536, + [1537] = 1537, + [1538] = 801, + [1539] = 802, + [1540] = 877, + [1541] = 878, + [1542] = 879, + [1543] = 881, + [1544] = 882, + [1545] = 883, + [1546] = 884, + [1547] = 885, + [1548] = 801, + [1549] = 788, + [1550] = 840, + [1551] = 836, + [1552] = 857, + [1553] = 858, + [1554] = 860, + [1555] = 841, + [1556] = 861, + [1557] = 842, + [1558] = 862, + [1559] = 843, + [1560] = 802, + [1561] = 1536, + [1562] = 1523, + [1563] = 1563, + [1564] = 833, + [1565] = 806, + [1566] = 859, + [1567] = 834, + [1568] = 835, + [1569] = 817, + [1570] = 1570, + [1571] = 1571, + [1572] = 1572, + [1573] = 833, + [1574] = 818, + [1575] = 1575, + [1576] = 832, + [1577] = 789, + [1578] = 819, + [1579] = 1002, + [1580] = 1580, + [1581] = 1581, + [1582] = 903, + [1583] = 905, + [1584] = 944, + [1585] = 1585, + [1586] = 804, + [1587] = 824, + [1588] = 1415, + [1589] = 766, + [1590] = 1590, + [1591] = 816, + [1592] = 495, + [1593] = 1393, + [1594] = 875, + [1595] = 1595, + [1596] = 834, + [1597] = 835, + [1598] = 859, + [1599] = 817, + [1600] = 822, + [1601] = 870, + [1602] = 904, + [1603] = 826, + [1604] = 949, + [1605] = 756, + [1606] = 494, + [1607] = 858, + [1608] = 1608, + [1609] = 916, + [1610] = 931, + [1611] = 917, + [1612] = 1612, + [1613] = 856, + [1614] = 798, + [1615] = 941, + [1616] = 1616, + [1617] = 445, + [1618] = 1618, + [1619] = 818, + [1620] = 832, + [1621] = 1411, + [1622] = 1622, + [1623] = 765, + [1624] = 873, + [1625] = 850, + [1626] = 851, + [1627] = 865, + [1628] = 860, + [1629] = 896, + [1630] = 1630, + [1631] = 880, + [1632] = 881, + [1633] = 868, + [1634] = 861, + [1635] = 836, + [1636] = 871, + [1637] = 826, + [1638] = 872, + [1639] = 877, + [1640] = 878, + [1641] = 898, + [1642] = 896, + [1643] = 898, + [1644] = 816, + [1645] = 824, + [1646] = 848, + [1647] = 843, + [1648] = 862, + [1649] = 819, + [1650] = 864, + [1651] = 879, + [1652] = 869, + [1653] = 840, + [1654] = 841, + [1655] = 842, + [1656] = 843, + [1657] = 866, + [1658] = 867, + [1659] = 884, + [1660] = 874, + [1661] = 856, + [1662] = 823, + [1663] = 882, + [1664] = 848, + [1665] = 883, + [1666] = 899, + [1667] = 864, + [1668] = 849, + [1669] = 849, + [1670] = 850, + [1671] = 851, + [1672] = 858, + [1673] = 885, + [1674] = 862, + [1675] = 841, + [1676] = 842, + [1677] = 857, + [1678] = 840, + [1679] = 941, + [1680] = 949, + [1681] = 1681, + [1682] = 885, + [1683] = 1683, + [1684] = 1683, + [1685] = 861, + [1686] = 867, + [1687] = 1687, + [1688] = 1688, + [1689] = 866, + [1690] = 1681, + [1691] = 865, + [1692] = 1683, + [1693] = 1687, + [1694] = 871, + [1695] = 931, + [1696] = 916, + [1697] = 1681, + [1698] = 917, + [1699] = 879, + [1700] = 872, + [1701] = 877, + [1702] = 836, + [1703] = 1683, + [1704] = 1681, + [1705] = 1705, + [1706] = 1687, + [1707] = 1687, + [1708] = 882, + [1709] = 904, + [1710] = 883, + [1711] = 1002, + [1712] = 905, + [1713] = 1681, + [1714] = 1683, + [1715] = 1687, + [1716] = 1681, + [1717] = 880, + [1718] = 1683, + [1719] = 1687, + [1720] = 881, + [1721] = 884, + [1722] = 1722, + [1723] = 857, + [1724] = 903, + [1725] = 878, + [1726] = 944, + [1727] = 873, + [1728] = 1728, + [1729] = 1729, + [1730] = 860, + [1731] = 475, + [1732] = 1732, + [1733] = 1733, + [1734] = 1734, + [1735] = 478, + [1736] = 899, + [1737] = 1737, + [1738] = 1738, + [1739] = 1739, + [1740] = 1740, + [1741] = 1741, + [1742] = 1742, + [1743] = 1743, + [1744] = 1744, + [1745] = 1745, + [1746] = 1746, + [1747] = 1747, + [1748] = 1748, + [1749] = 1749, + [1750] = 1750, + [1751] = 1751, + [1752] = 1752, + [1753] = 1753, + [1754] = 1754, + [1755] = 1755, + [1756] = 1756, + [1757] = 1757, + [1758] = 1758, + [1759] = 1759, + [1760] = 1760, + [1761] = 1761, + [1762] = 1762, + [1763] = 1763, + [1764] = 1764, + [1765] = 1765, + [1766] = 1766, + [1767] = 1767, + [1768] = 1768, + [1769] = 1769, + [1770] = 1770, + [1771] = 1771, + [1772] = 1772, + [1773] = 1773, + [1774] = 1774, + [1775] = 1775, + [1776] = 1776, + [1777] = 1777, + [1778] = 1778, + [1779] = 1779, + [1780] = 1780, + [1781] = 1781, + [1782] = 1782, + [1783] = 1783, + [1784] = 1784, + [1785] = 1785, + [1786] = 1786, + [1787] = 1787, + [1788] = 1788, + [1789] = 1789, + [1790] = 1790, + [1791] = 1791, + [1792] = 1792, + [1793] = 1793, + [1794] = 1794, + [1795] = 1795, + [1796] = 1796, + [1797] = 1797, + [1798] = 1798, + [1799] = 1799, + [1800] = 1800, + [1801] = 1801, + [1802] = 1802, + [1803] = 1803, + [1804] = 1804, + [1805] = 1805, + [1806] = 1806, + [1807] = 1807, + [1808] = 1808, + [1809] = 1809, + [1810] = 1810, + [1811] = 1811, + [1812] = 1812, + [1813] = 1813, + [1814] = 1814, + [1815] = 1815, + [1816] = 1816, + [1817] = 1817, + [1818] = 1818, + [1819] = 1819, + [1820] = 1820, + [1821] = 1821, + [1822] = 1822, + [1823] = 1823, + [1824] = 1824, + [1825] = 1825, + [1826] = 1826, + [1827] = 1827, + [1828] = 1828, + [1829] = 1829, + [1830] = 1830, + [1831] = 1831, + [1832] = 1832, + [1833] = 1833, + [1834] = 628, + [1835] = 629, + [1836] = 618, + [1837] = 619, + [1838] = 1838, + [1839] = 632, + [1840] = 633, + [1841] = 634, + [1842] = 635, + [1843] = 607, + [1844] = 636, + [1845] = 637, + [1846] = 608, + [1847] = 1847, + [1848] = 1848, + [1849] = 1849, + [1850] = 1833, + [1851] = 1851, + [1852] = 1852, + [1853] = 1853, + [1854] = 622, + [1855] = 1855, + [1856] = 1856, + [1857] = 1857, + [1858] = 623, + [1859] = 1838, + [1860] = 1860, + [1861] = 1852, + [1862] = 625, + [1863] = 626, + [1864] = 1864, + [1865] = 1865, + [1866] = 1866, + [1867] = 1838, + [1868] = 1860, + [1869] = 1852, + [1870] = 1838, + [1871] = 1860, + [1872] = 1852, + [1873] = 1873, + [1874] = 1838, + [1875] = 1860, + [1876] = 1852, + [1877] = 1838, + [1878] = 1860, + [1879] = 1852, + [1880] = 1851, + [1881] = 1848, + [1882] = 1833, + [1883] = 1857, + [1884] = 1865, + [1885] = 1851, + [1886] = 1848, + [1887] = 1833, + [1888] = 1857, + [1889] = 1865, + [1890] = 1851, + [1891] = 1848, + [1892] = 1833, + [1893] = 1857, + [1894] = 1865, + [1895] = 1851, + [1896] = 1848, + [1897] = 627, + [1898] = 1857, + [1899] = 1865, + [1900] = 1851, + [1901] = 1848, + [1902] = 1833, + [1903] = 1857, + [1904] = 1865, + [1905] = 1860, + [1906] = 1906, + [1907] = 1906, + [1908] = 1908, + [1909] = 1909, + [1910] = 1910, + [1911] = 1911, + [1912] = 1912, + [1913] = 1913, + [1914] = 1914, + [1915] = 1915, + [1916] = 1916, + [1917] = 1917, + [1918] = 1733, + [1919] = 1919, + [1920] = 1920, + [1921] = 1906, + [1922] = 1914, + [1923] = 1923, + [1924] = 1908, + [1925] = 1914, + [1926] = 1906, + [1927] = 1908, + [1928] = 1914, + [1929] = 1906, + [1930] = 1908, + [1931] = 1914, + [1932] = 1906, + [1933] = 1908, + [1934] = 1914, + [1935] = 1908, + [1936] = 1936, + [1937] = 1937, + [1938] = 1938, + [1939] = 1939, + [1940] = 1940, + [1941] = 1939, + [1942] = 1940, + [1943] = 1943, + [1944] = 1939, + [1945] = 1945, + [1946] = 1940, + [1947] = 1947, + [1948] = 1948, + [1949] = 1939, + [1950] = 1940, + [1951] = 1940, + [1952] = 1952, + [1953] = 1953, + [1954] = 1954, + [1955] = 1955, + [1956] = 1952, + [1957] = 1954, + [1958] = 1958, + [1959] = 1958, + [1960] = 1952, + [1961] = 1954, + [1962] = 1962, + [1963] = 1954, + [1964] = 1954, + [1965] = 1954, + [1966] = 1966, + [1967] = 1967, + [1968] = 1968, + [1969] = 1958, + [1970] = 1952, + [1971] = 1971, + [1972] = 1972, + [1973] = 1952, + [1974] = 1954, + [1975] = 1975, + [1976] = 1976, + [1977] = 1958, + [1978] = 667, + [1979] = 1979, + [1980] = 1980, + [1981] = 1981, + [1982] = 1954, + [1983] = 1954, + [1984] = 1958, + [1985] = 952, + [1986] = 905, + [1987] = 939, + [1988] = 908, + [1989] = 1989, + [1990] = 954, + [1991] = 976, + [1992] = 941, + [1993] = 1993, + [1994] = 1002, + [1995] = 628, + [1996] = 633, + [1997] = 634, + [1998] = 635, + [1999] = 625, + [2000] = 636, + [2001] = 637, + [2002] = 608, + [2003] = 822, + [2004] = 626, + [2005] = 2005, + [2006] = 627, + [2007] = 623, + [2008] = 2008, + [2009] = 2009, + [2010] = 2010, + [2011] = 927, + [2012] = 629, + [2013] = 618, + [2014] = 2014, + [2015] = 2015, + [2016] = 1909, + [2017] = 2017, + [2018] = 2018, + [2019] = 2019, + [2020] = 619, + [2021] = 2021, + [2022] = 2022, + [2023] = 2023, + [2024] = 2024, + [2025] = 632, + [2026] = 622, + [2027] = 607, + [2028] = 2028, + [2029] = 2029, + [2030] = 2030, + [2031] = 2031, + [2032] = 2032, + [2033] = 2028, + [2034] = 2034, + [2035] = 2035, + [2036] = 2036, + [2037] = 2037, + [2038] = 2038, + [2039] = 2039, + [2040] = 2040, + [2041] = 2041, + [2042] = 2028, + [2043] = 2043, + [2044] = 2044, + [2045] = 2045, + [2046] = 2046, + [2047] = 2047, + [2048] = 2048, + [2049] = 2049, + [2050] = 2028, + [2051] = 2051, + [2052] = 2052, + [2053] = 2053, + [2054] = 2028, + [2055] = 2055, + [2056] = 2056, + [2057] = 2057, + [2058] = 2028, + [2059] = 2059, + [2060] = 2028, + [2061] = 2061, + [2062] = 2062, + [2063] = 2063, + [2064] = 2064, + [2065] = 2028, + [2066] = 2066, + [2067] = 2067, + [2068] = 2068, + [2069] = 2069, + [2070] = 2070, + [2071] = 2071, + [2072] = 2072, + [2073] = 2073, + [2074] = 2074, + [2075] = 2075, + [2076] = 2076, + [2077] = 2077, + [2078] = 2078, + [2079] = 2079, + [2080] = 2078, + [2081] = 2081, + [2082] = 2082, + [2083] = 2083, + [2084] = 2084, + [2085] = 2085, + [2086] = 2086, + [2087] = 2087, + [2088] = 2088, + [2089] = 2089, + [2090] = 868, + [2091] = 2087, + [2092] = 2088, + [2093] = 2093, + [2094] = 2094, + [2095] = 874, + [2096] = 2096, + [2097] = 2097, + [2098] = 2098, + [2099] = 2099, + [2100] = 2087, + [2101] = 2101, + [2102] = 2088, + [2103] = 2103, + [2104] = 2081, + [2105] = 2105, + [2106] = 2087, + [2107] = 2081, + [2108] = 2088, + [2109] = 2109, + [2110] = 821, + [2111] = 2081, + [2112] = 2112, + [2113] = 2113, + [2114] = 2114, + [2115] = 828, + [2116] = 2116, + [2117] = 2117, + [2118] = 2118, + [2119] = 2119, + [2120] = 2120, + [2121] = 2121, + [2122] = 2122, + [2123] = 2119, + [2124] = 2124, + [2125] = 2125, + [2126] = 2087, + [2127] = 2088, + [2128] = 2128, + [2129] = 2129, + [2130] = 2130, + [2131] = 2131, + [2132] = 2132, + [2133] = 994, + [2134] = 995, + [2135] = 996, + [2136] = 998, + [2137] = 2137, + [2138] = 2138, + [2139] = 989, + [2140] = 997, + [2141] = 2141, + [2142] = 2142, + [2143] = 2143, + [2144] = 2144, + [2145] = 933, + [2146] = 2146, + [2147] = 2147, + [2148] = 2148, + [2149] = 599, + [2150] = 2150, + [2151] = 993, + [2152] = 2152, + [2153] = 2153, + [2154] = 2154, + [2155] = 2155, + [2156] = 902, + [2157] = 600, + [2158] = 2158, + [2159] = 2159, + [2160] = 2160, + [2161] = 758, + [2162] = 2162, + [2163] = 828, + [2164] = 2164, + [2165] = 869, + [2166] = 2166, + [2167] = 2167, + [2168] = 2168, + [2169] = 757, + [2170] = 2170, + [2171] = 2171, + [2172] = 821, + [2173] = 821, + [2174] = 2174, + [2175] = 2175, + [2176] = 2176, + [2177] = 2177, + [2178] = 2178, + [2179] = 2179, + [2180] = 2180, + [2181] = 2177, + [2182] = 2182, + [2183] = 2182, + [2184] = 2184, + [2185] = 2185, + [2186] = 765, + [2187] = 756, + [2188] = 766, + [2189] = 2179, + [2190] = 2190, + [2191] = 989, + [2192] = 2184, + [2193] = 2177, + [2194] = 2194, + [2195] = 2182, + [2196] = 823, + [2197] = 2184, + [2198] = 2179, + [2199] = 2179, + [2200] = 2179, + [2201] = 2201, + [2202] = 2202, + [2203] = 2203, + [2204] = 2204, + [2205] = 2177, + [2206] = 2182, + [2207] = 2207, + [2208] = 2184, + [2209] = 2177, + [2210] = 2184, + [2211] = 2182, + [2212] = 2212, + [2213] = 2213, + [2214] = 2214, + [2215] = 804, + [2216] = 2216, + [2217] = 806, + [2218] = 2212, + [2219] = 2219, + [2220] = 2220, + [2221] = 2221, + [2222] = 2222, + [2223] = 2223, + [2224] = 2224, + [2225] = 2225, + [2226] = 2226, + [2227] = 2227, + [2228] = 2228, + [2229] = 2229, + [2230] = 2230, + [2231] = 2231, + [2232] = 2232, + [2233] = 2233, + [2234] = 2234, + [2235] = 2235, + [2236] = 2219, + [2237] = 2237, + [2238] = 2238, + [2239] = 2239, + [2240] = 2240, + [2241] = 2235, + [2242] = 2242, + [2243] = 2243, + [2244] = 2244, + [2245] = 2245, + [2246] = 2237, + [2247] = 2242, + [2248] = 2233, + [2249] = 2249, + [2250] = 789, + [2251] = 2212, + [2252] = 2252, + [2253] = 2237, + [2254] = 2238, + [2255] = 2240, + [2256] = 2235, + [2257] = 2242, + [2258] = 2243, + [2259] = 2259, + [2260] = 2260, + [2261] = 931, + [2262] = 2212, + [2263] = 2219, + [2264] = 2238, + [2265] = 2237, + [2266] = 2238, + [2267] = 2240, + [2268] = 2235, + [2269] = 2242, + [2270] = 2243, + [2271] = 798, + [2272] = 2212, + [2273] = 2219, + [2274] = 2274, + [2275] = 2237, + [2276] = 2238, + [2277] = 2240, + [2278] = 2235, + [2279] = 2242, + [2280] = 2243, + [2281] = 2281, + [2282] = 2243, + [2283] = 2240, + [2284] = 2284, + [2285] = 2285, + [2286] = 2286, + [2287] = 2284, + [2288] = 2219, + [2289] = 2289, + [2290] = 839, + [2291] = 2291, + [2292] = 2292, + [2293] = 2293, + [2294] = 2294, + [2295] = 2295, + [2296] = 2296, + [2297] = 2297, + [2298] = 2298, + [2299] = 2299, + [2300] = 2300, + [2301] = 2301, + [2302] = 2302, + [2303] = 2303, + [2304] = 2304, + [2305] = 2303, + [2306] = 2306, + [2307] = 984, + [2308] = 2308, + [2309] = 2309, + [2310] = 2310, + [2311] = 2311, + [2312] = 2312, + [2313] = 2313, + [2314] = 2314, + [2315] = 2315, + [2316] = 2316, + [2317] = 2297, + [2318] = 2298, + [2319] = 2319, + [2320] = 2320, + [2321] = 2321, + [2322] = 2322, + [2323] = 2303, + [2324] = 2304, + [2325] = 985, + [2326] = 2297, + [2327] = 2327, + [2328] = 2304, + [2329] = 2297, + [2330] = 2298, + [2331] = 2297, + [2332] = 2298, + [2333] = 2333, + [2334] = 2298, + [2335] = 2335, + [2336] = 2336, + [2337] = 2337, + [2338] = 2303, + [2339] = 2304, + [2340] = 2340, + [2341] = 2303, + [2342] = 2304, + [2343] = 2343, + [2344] = 2344, + [2345] = 2337, + [2346] = 2346, + [2347] = 2347, + [2348] = 2348, + [2349] = 2337, + [2350] = 2350, + [2351] = 863, + [2352] = 2352, + [2353] = 2337, + [2354] = 2354, + [2355] = 2355, + [2356] = 2337, + [2357] = 2357, + [2358] = 2337, + [2359] = 2359, + [2360] = 2360, + [2361] = 2361, + [2362] = 2362, + [2363] = 2363, + [2364] = 994, + [2365] = 2365, + [2366] = 995, + [2367] = 2362, + [2368] = 558, + [2369] = 552, + [2370] = 554, + [2371] = 555, + [2372] = 2372, + [2373] = 574, + [2374] = 2374, + [2375] = 921, + [2376] = 923, + [2377] = 924, + [2378] = 925, + [2379] = 2379, + [2380] = 935, + [2381] = 945, + [2382] = 947, + [2383] = 950, + [2384] = 1816, + [2385] = 2385, + [2386] = 980, + [2387] = 987, + [2388] = 996, + [2389] = 2389, + [2390] = 956, + [2391] = 997, + [2392] = 2392, + [2393] = 2393, + [2394] = 1003, + [2395] = 972, + [2396] = 974, + [2397] = 975, + [2398] = 2398, + [2399] = 2399, + [2400] = 977, + [2401] = 2401, + [2402] = 981, + [2403] = 982, + [2404] = 998, + [2405] = 2405, + [2406] = 1004, + [2407] = 2407, + [2408] = 2408, + [2409] = 2409, + [2410] = 993, + [2411] = 2411, + [2412] = 926, + [2413] = 2413, + [2414] = 2414, + [2415] = 918, + [2416] = 898, + [2417] = 2393, + [2418] = 2418, + [2419] = 920, + [2420] = 930, + [2421] = 2393, + [2422] = 2422, + [2423] = 2423, + [2424] = 2424, + [2425] = 2425, + [2426] = 1005, + [2427] = 2427, + [2428] = 933, + [2429] = 593, + [2430] = 900, + [2431] = 1001, + [2432] = 979, + [2433] = 864, + [2434] = 915, + [2435] = 1006, + [2436] = 2393, + [2437] = 2437, + [2438] = 901, + [2439] = 2439, + [2440] = 582, + [2441] = 959, + [2442] = 961, + [2443] = 962, + [2444] = 2444, + [2445] = 2445, + [2446] = 2446, + [2447] = 896, + [2448] = 922, + [2449] = 2449, + [2450] = 2450, + [2451] = 2444, + [2452] = 2445, + [2453] = 934, + [2454] = 2454, + [2455] = 2455, + [2456] = 940, + [2457] = 942, + [2458] = 902, + [2459] = 2459, + [2460] = 2460, + [2461] = 946, + [2462] = 2462, + [2463] = 943, + [2464] = 2407, + [2465] = 2449, + [2466] = 2466, + [2467] = 2467, + [2468] = 2468, + [2469] = 2469, + [2470] = 2470, + [2471] = 2470, + [2472] = 2472, + [2473] = 2473, + [2474] = 2474, + [2475] = 2362, + [2476] = 2476, + [2477] = 2477, + [2478] = 2478, + [2479] = 2479, + [2480] = 2480, + [2481] = 2481, + [2482] = 2470, + [2483] = 2483, + [2484] = 2484, + [2485] = 2485, + [2486] = 2486, + [2487] = 2487, + [2488] = 2488, + [2489] = 2489, + [2490] = 2490, + [2491] = 2491, + [2492] = 2492, + [2493] = 2493, + [2494] = 2494, + [2495] = 2495, + [2496] = 2470, + [2497] = 2497, + [2498] = 2498, + [2499] = 2499, + [2500] = 2500, + [2501] = 2501, + [2502] = 2171, + [2503] = 2503, + [2504] = 2164, + [2505] = 2505, + [2506] = 2483, + [2507] = 2507, + [2508] = 2508, + [2509] = 2489, + [2510] = 2510, + [2511] = 2511, + [2512] = 2512, + [2513] = 2362, + [2514] = 2514, + [2515] = 2515, + [2516] = 2516, + [2517] = 2517, + [2518] = 2362, + [2519] = 2519, + [2520] = 2520, + [2521] = 2521, + [2522] = 2522, + [2523] = 2519, + [2524] = 2524, + [2525] = 2525, + [2526] = 2484, + [2527] = 2527, + [2528] = 2507, + [2529] = 2470, + [2530] = 2494, + [2531] = 2531, + [2532] = 2532, + [2533] = 2533, + [2534] = 2534, + [2535] = 2535, + [2536] = 2536, + [2537] = 2537, + [2538] = 2538, + [2539] = 2539, + [2540] = 2540, + [2541] = 2541, + [2542] = 2542, + [2543] = 2469, + [2544] = 2362, + [2545] = 2545, + [2546] = 2546, + [2547] = 2547, + [2548] = 2548, + [2549] = 2549, + [2550] = 2550, + [2551] = 2551, + [2552] = 2552, + [2553] = 2473, + [2554] = 2554, + [2555] = 2555, + [2556] = 2556, + [2557] = 2557, + [2558] = 2558, + [2559] = 2559, + [2560] = 2560, + [2561] = 2561, + [2562] = 2562, + [2563] = 2563, + [2564] = 2564, + [2565] = 2565, + [2566] = 2566, + [2567] = 2567, + [2568] = 2568, + [2569] = 2569, + [2570] = 2570, + [2571] = 2571, + [2572] = 2572, + [2573] = 2573, + [2574] = 2574, + [2575] = 2575, + [2576] = 2576, + [2577] = 2483, + [2578] = 2578, + [2579] = 2579, + [2580] = 2580, + [2581] = 2581, + [2582] = 2582, + [2583] = 2583, + [2584] = 2584, + [2585] = 2585, + [2586] = 2586, + [2587] = 2587, + [2588] = 2588, + [2589] = 2589, + [2590] = 2590, + [2591] = 2591, + [2592] = 2592, + [2593] = 2593, + [2594] = 2594, + [2595] = 2595, + [2596] = 2596, + [2597] = 2597, + [2598] = 2598, + [2599] = 2599, + [2600] = 2600, + [2601] = 2601, + [2602] = 2602, + [2603] = 2473, + [2604] = 2604, + [2605] = 2605, + [2606] = 2606, + [2607] = 2607, + [2608] = 2608, + [2609] = 2609, + [2610] = 2610, + [2611] = 2611, + [2612] = 2473, + [2613] = 2483, + [2614] = 2362, + [2615] = 2615, + [2616] = 2616, + [2617] = 2617, + [2618] = 2519, + [2619] = 2619, + [2620] = 2620, + [2621] = 2621, + [2622] = 2622, + [2623] = 2623, + [2624] = 2362, + [2625] = 2519, + [2626] = 2626, + [2627] = 2627, + [2628] = 2628, + [2629] = 2629, + [2630] = 2630, + [2631] = 2631, + [2632] = 2632, + [2633] = 2633, + [2634] = 2628, + [2635] = 2635, + [2636] = 2636, + [2637] = 2637, + [2638] = 2629, + [2639] = 2635, + [2640] = 2640, + [2641] = 2629, + [2642] = 2642, + [2643] = 2643, + [2644] = 2644, + [2645] = 2629, + [2646] = 2635, + [2647] = 2629, + [2648] = 2648, + [2649] = 2629, + [2650] = 2628, + [2651] = 2651, + [2652] = 2652, + [2653] = 2653, + [2654] = 2654, + [2655] = 2655, + [2656] = 2644, + [2657] = 2657, + [2658] = 2628, + [2659] = 2659, + [2660] = 2660, + [2661] = 2661, + [2662] = 2628, + [2663] = 2663, + [2664] = 2664, + [2665] = 2665, + [2666] = 2666, + [2667] = 2667, + [2668] = 2668, + [2669] = 2669, + [2670] = 2670, + [2671] = 2671, + [2672] = 2672, + [2673] = 2629, + [2674] = 2635, + [2675] = 2675, + [2676] = 2676, + [2677] = 2677, + [2678] = 2678, + [2679] = 2644, + [2680] = 2644, + [2681] = 2681, + [2682] = 2682, + [2683] = 2683, + [2684] = 2628, + [2685] = 2685, + [2686] = 2686, + [2687] = 2687, + [2688] = 2688, + [2689] = 2689, + [2690] = 2690, + [2691] = 2691, + [2692] = 2628, + [2693] = 2693, + [2694] = 2694, + [2695] = 2657, + [2696] = 2635, + [2697] = 2697, + [2698] = 2698, + [2699] = 2629, + [2700] = 2700, + [2701] = 2666, + [2702] = 2702, + [2703] = 2703, + [2704] = 2704, + [2705] = 2705, + [2706] = 2706, + [2707] = 2707, + [2708] = 2708, + [2709] = 2709, + [2710] = 2710, + [2711] = 2711, + [2712] = 2712, + [2713] = 2713, + [2714] = 2714, + [2715] = 2715, + [2716] = 2716, + [2717] = 2717, + [2718] = 2718, + [2719] = 2719, + [2720] = 2720, + [2721] = 2721, + [2722] = 2722, + [2723] = 2723, + [2724] = 2724, + [2725] = 2725, + [2726] = 2726, + [2727] = 2727, + [2728] = 2728, + [2729] = 2729, + [2730] = 2730, + [2731] = 2731, + [2732] = 2732, + [2733] = 2733, + [2734] = 2734, + [2735] = 2735, + [2736] = 2736, + [2737] = 2737, + [2738] = 2738, + [2739] = 2739, + [2740] = 2740, + [2741] = 2741, + [2742] = 2742, + [2743] = 2743, + [2744] = 2744, + [2745] = 2745, + [2746] = 2746, + [2747] = 2747, + [2748] = 2748, + [2749] = 2749, + [2750] = 2750, + [2751] = 2751, + [2752] = 2752, + [2753] = 2753, + [2754] = 2754, + [2755] = 2755, + [2756] = 2756, + [2757] = 2757, + [2758] = 2758, + [2759] = 2759, + [2760] = 2760, + [2761] = 2761, + [2762] = 2762, + [2763] = 2763, + [2764] = 2764, + [2765] = 2765, + [2766] = 2766, + [2767] = 2767, + [2768] = 2768, + [2769] = 2741, + [2770] = 2770, + [2771] = 2771, + [2772] = 2772, + [2773] = 2336, + [2774] = 2340, + [2775] = 2343, + [2776] = 2776, + [2777] = 2777, + [2778] = 2357, + [2779] = 2779, + [2780] = 2780, + [2781] = 2781, + [2782] = 2782, + [2783] = 2783, + [2784] = 2784, + [2785] = 2785, + [2786] = 2786, + [2787] = 2787, + [2788] = 2788, + [2789] = 2314, + [2790] = 2722, + [2791] = 2791, + [2792] = 2708, + [2793] = 2793, + [2794] = 2794, + [2795] = 2762, + [2796] = 2796, + [2797] = 2797, + [2798] = 2772, + [2799] = 2779, + [2800] = 2800, + [2801] = 2801, + [2802] = 2802, + [2803] = 2717, + [2804] = 2804, + [2805] = 2333, + [2806] = 2806, + [2807] = 2807, + [2808] = 2808, + [2809] = 2809, + [2810] = 2810, + [2811] = 2811, + [2812] = 2812, + [2813] = 2813, + [2814] = 2320, + [2815] = 2321, + [2816] = 2766, + [2817] = 2757, + [2818] = 2806, + [2819] = 2807, + [2820] = 2293, + [2821] = 2821, + [2822] = 2784, + [2823] = 2823, + [2824] = 2824, + [2825] = 2825, + [2826] = 2826, + [2827] = 2827, + [2828] = 2828, + [2829] = 2829, + [2830] = 2804, + [2831] = 2831, + [2832] = 2832, + [2833] = 2833, + [2834] = 2834, + [2835] = 2835, + [2836] = 2836, + [2837] = 2757, + [2838] = 2838, + [2839] = 2839, + [2840] = 2840, + [2841] = 2765, + [2842] = 2842, + [2843] = 2767, + [2844] = 2788, + [2845] = 2845, + [2846] = 2741, + [2847] = 2847, + [2848] = 2848, + [2849] = 2849, + [2850] = 2850, + [2851] = 2851, + [2852] = 2852, + [2853] = 2776, + [2854] = 2777, + [2855] = 2780, + [2856] = 2781, + [2857] = 2782, + [2858] = 2858, + [2859] = 2784, + [2860] = 2860, + [2861] = 2861, + [2862] = 2862, + [2863] = 2788, + [2864] = 2722, + [2865] = 2708, + [2866] = 2794, + [2867] = 2762, + [2868] = 2796, + [2869] = 2772, + [2870] = 2779, + [2871] = 2871, + [2872] = 2872, + [2873] = 2873, + [2874] = 2717, + [2875] = 2875, + [2876] = 2808, + [2877] = 2809, + [2878] = 2810, + [2879] = 2811, + [2880] = 2812, + [2881] = 2881, + [2882] = 2766, + [2883] = 2883, + [2884] = 2884, + [2885] = 2806, + [2886] = 2807, + [2887] = 2887, + [2888] = 2888, + [2889] = 2889, + [2890] = 2890, + [2891] = 2757, + [2892] = 2765, + [2893] = 2767, + [2894] = 2894, + [2895] = 2895, + [2896] = 2896, + [2897] = 2741, + [2898] = 2898, + [2899] = 2899, + [2900] = 2776, + [2901] = 2777, + [2902] = 2780, + [2903] = 2781, + [2904] = 2782, + [2905] = 2905, + [2906] = 2784, + [2907] = 2907, + [2908] = 2908, + [2909] = 2794, + [2910] = 2910, + [2911] = 2911, + [2912] = 2788, + [2913] = 2776, + [2914] = 2722, + [2915] = 2915, + [2916] = 2708, + [2917] = 2794, + [2918] = 2762, + [2919] = 2796, + [2920] = 2772, + [2921] = 2779, + [2922] = 2922, + [2923] = 2808, + [2924] = 2809, + [2925] = 2810, + [2926] = 2811, + [2927] = 2812, + [2928] = 2766, + [2929] = 2806, + [2930] = 2807, + [2931] = 2781, + [2932] = 2757, + [2933] = 2933, + [2934] = 2934, + [2935] = 2935, + [2936] = 2936, + [2937] = 2937, + [2938] = 2765, + [2939] = 2765, + [2940] = 2940, + [2941] = 2741, + [2942] = 2942, + [2943] = 2776, + [2944] = 2777, + [2945] = 2945, + [2946] = 2780, + [2947] = 2717, + [2948] = 2948, + [2949] = 2949, + [2950] = 2722, + [2951] = 2951, + [2952] = 2708, + [2953] = 2953, + [2954] = 2954, + [2955] = 2757, + [2956] = 2956, + [2957] = 2765, + [2958] = 2741, + [2959] = 2776, + [2960] = 2777, + [2961] = 2796, + [2962] = 2780, + [2963] = 2722, + [2964] = 2708, + [2965] = 2965, + [2966] = 2966, + [2967] = 2967, + [2968] = 2776, + [2969] = 2722, + [2970] = 2767, + [2971] = 2971, + [2972] = 2776, + [2973] = 2722, + [2974] = 2974, + [2975] = 2975, + [2976] = 2782, + [2977] = 2300, + [2978] = 2978, + [2979] = 2295, + [2980] = 2299, + [2981] = 2888, + [2982] = 2982, + [2983] = 2983, + [2984] = 2783, + [2985] = 2985, + [2986] = 2832, + [2987] = 2987, + [2988] = 2746, + [2989] = 2748, + [2990] = 2327, + [2991] = 2835, + [2992] = 2808, + [2993] = 2723, + [2994] = 2734, + [2995] = 2888, + [2996] = 2996, + [2997] = 2997, + [2998] = 2783, + [2999] = 2999, + [3000] = 3000, + [3001] = 3001, + [3002] = 3002, + [3003] = 3003, + [3004] = 2832, + [3005] = 3005, + [3006] = 3006, + [3007] = 2746, + [3008] = 2748, + [3009] = 2723, + [3010] = 2777, + [3011] = 2888, + [3012] = 3012, + [3013] = 3013, + [3014] = 2783, + [3015] = 2832, + [3016] = 2746, + [3017] = 2748, + [3018] = 2723, + [3019] = 2888, + [3020] = 3020, + [3021] = 2783, + [3022] = 3022, + [3023] = 2832, + [3024] = 2746, + [3025] = 2748, + [3026] = 2723, + [3027] = 2888, + [3028] = 2783, + [3029] = 3029, + [3030] = 3030, + [3031] = 2809, + [3032] = 2832, + [3033] = 2810, + [3034] = 2746, + [3035] = 2748, + [3036] = 2723, + [3037] = 2987, + [3038] = 2811, + [3039] = 2812, + [3040] = 3040, + [3041] = 3041, + [3042] = 2780, + [3043] = 2829, + [3044] = 3044, + [3045] = 3045, + [3046] = 3046, + [3047] = 3047, + [3048] = 3048, + [3049] = 3049, + [3050] = 3050, + [3051] = 3051, + [3052] = 3052, + [3053] = 3053, + [3054] = 3054, + [3055] = 3055, + [3056] = 3056, + [3057] = 3057, + [3058] = 3058, + [3059] = 3059, + [3060] = 3060, + [3061] = 3061, + [3062] = 3062, + [3063] = 3063, + [3064] = 3064, + [3065] = 3065, + [3066] = 3066, + [3067] = 3067, + [3068] = 3068, + [3069] = 3069, + [3070] = 3070, + [3071] = 3071, + [3072] = 3072, + [3073] = 3073, + [3074] = 3074, + [3075] = 3075, + [3076] = 3076, + [3077] = 3077, + [3078] = 3078, + [3079] = 3079, + [3080] = 3080, + [3081] = 3081, + [3082] = 3082, + [3083] = 3083, + [3084] = 3084, + [3085] = 3085, + [3086] = 3086, + [3087] = 3087, + [3088] = 3088, + [3089] = 3089, + [3090] = 3090, + [3091] = 3091, + [3092] = 3092, + [3093] = 3093, + [3094] = 3067, + [3095] = 3095, + [3096] = 3096, + [3097] = 3097, + [3098] = 3098, + [3099] = 3073, + [3100] = 3100, + [3101] = 3101, + [3102] = 3102, + [3103] = 3103, + [3104] = 3104, + [3105] = 3105, + [3106] = 3106, + [3107] = 3107, + [3108] = 3108, + [3109] = 3109, + [3110] = 3110, + [3111] = 3047, + [3112] = 3112, + [3113] = 3092, + [3114] = 3114, + [3115] = 3115, + [3116] = 3116, + [3117] = 3117, + [3118] = 3118, + [3119] = 3119, + [3120] = 3120, + [3121] = 3121, + [3122] = 3061, + [3123] = 3123, + [3124] = 3124, + [3125] = 3125, + [3126] = 3126, + [3127] = 3127, + [3128] = 3128, + [3129] = 3129, + [3130] = 3130, + [3131] = 3131, + [3132] = 3132, + [3133] = 3133, + [3134] = 3134, + [3135] = 3135, + [3136] = 3136, + [3137] = 3137, + [3138] = 3138, + [3139] = 3139, + [3140] = 3140, + [3141] = 3141, + [3142] = 3142, + [3143] = 3143, + [3144] = 3144, + [3145] = 3145, + [3146] = 3087, + [3147] = 3147, + [3148] = 3148, + [3149] = 3149, + [3150] = 3150, + [3151] = 3090, + [3152] = 3152, + [3153] = 3153, + [3154] = 3067, + [3155] = 3155, + [3156] = 3073, + [3157] = 3157, + [3158] = 3087, + [3159] = 3159, + [3160] = 3160, + [3161] = 3161, + [3162] = 3106, + [3163] = 3163, + [3164] = 3164, + [3165] = 3165, + [3166] = 3166, + [3167] = 3110, + [3168] = 3090, + [3169] = 3169, + [3170] = 3092, + [3171] = 3171, + [3172] = 3172, + [3173] = 3173, + [3174] = 3174, + [3175] = 3061, + [3176] = 3176, + [3177] = 3177, + [3178] = 3178, + [3179] = 3179, + [3180] = 3180, + [3181] = 3181, + [3182] = 3182, + [3183] = 3067, + [3184] = 3184, + [3185] = 3185, + [3186] = 3186, + [3187] = 3187, + [3188] = 3188, + [3189] = 3189, + [3190] = 3190, + [3191] = 3191, + [3192] = 3192, + [3193] = 3097, + [3194] = 3194, + [3195] = 3073, + [3196] = 3196, + [3197] = 3197, + [3198] = 3198, + [3199] = 3090, + [3200] = 3200, + [3201] = 3201, + [3202] = 3067, + [3203] = 3110, + [3204] = 3204, + [3205] = 3205, + [3206] = 3206, + [3207] = 3112, + [3208] = 3208, + [3209] = 3097, + [3210] = 3210, + [3211] = 3106, + [3212] = 3212, + [3213] = 3213, + [3214] = 3067, + [3215] = 3215, + [3216] = 3110, + [3217] = 3217, + [3218] = 3218, + [3219] = 3067, + [3220] = 3220, + [3221] = 3221, + [3222] = 3047, + [3223] = 3223, + [3224] = 3067, + [3225] = 3067, + [3226] = 3067, + [3227] = 3092, + [3228] = 3067, + [3229] = 3229, + [3230] = 3067, + [3231] = 3067, + [3232] = 3232, + [3233] = 3233, + [3234] = 3234, + [3235] = 3235, + [3236] = 3077, + [3237] = 3143, + [3238] = 3090, + [3239] = 3239, + [3240] = 3240, + [3241] = 3180, + [3242] = 3242, + [3243] = 3243, + [3244] = 3244, + [3245] = 3245, + [3246] = 3246, + [3247] = 3097, + [3248] = 3248, + [3249] = 3201, + [3250] = 3250, + [3251] = 3251, + [3252] = 3252, + [3253] = 3253, + [3254] = 3087, + [3255] = 3121, + [3256] = 3256, + [3257] = 544, + [3258] = 527, + [3259] = 3259, + [3260] = 3260, + [3261] = 3261, + [3262] = 3082, + [3263] = 3143, + [3264] = 3061, + [3265] = 3110, + [3266] = 3180, + [3267] = 3267, + [3268] = 3246, + [3269] = 3243, + [3270] = 3270, + [3271] = 3246, + [3272] = 3272, + [3273] = 3273, + [3274] = 3274, + [3275] = 3275, + [3276] = 3106, + [3277] = 3277, + [3278] = 3278, + [3279] = 3051, + [3280] = 3053, + [3281] = 3281, + [3282] = 3180, + [3283] = 3243, + [3284] = 3246, + [3285] = 3285, + [3286] = 3286, + [3287] = 3287, + [3288] = 3243, + [3289] = 3289, + [3290] = 3290, + [3291] = 3291, + [3292] = 3292, + [3293] = 3293, + [3294] = 3294, + [3295] = 3295, + [3296] = 3296, + [3297] = 3297, + [3298] = 3298, + [3299] = 3299, + [3300] = 3250, + [3301] = 3301, + [3302] = 3302, + [3303] = 3303, + [3304] = 3244, + [3305] = 3305, + [3306] = 3306, + [3307] = 3307, + [3308] = 3308, + [3309] = 3309, + [3310] = 3310, + [3311] = 3311, + [3312] = 3312, + [3313] = 3313, + [3314] = 3314, + [3315] = 3235, + [3316] = 3316, + [3317] = 3317, + [3318] = 3121, + [3319] = 3319, + [3320] = 3320, + [3321] = 3066, + [3322] = 3066, + [3323] = 3066, + [3324] = 3324, + [3325] = 3325, + [3326] = 3326, + [3327] = 3327, + [3328] = 3328, + [3329] = 3329, + [3330] = 3330, + [3331] = 3331, + [3332] = 3332, + [3333] = 3333, + [3334] = 3334, + [3335] = 3335, + [3336] = 3336, + [3337] = 3337, + [3338] = 3338, + [3339] = 3336, + [3340] = 3340, + [3341] = 3341, + [3342] = 3342, + [3343] = 3343, + [3344] = 3344, + [3345] = 3345, + [3346] = 3346, + [3347] = 3347, + [3348] = 3348, + [3349] = 3349, + [3350] = 3350, + [3351] = 3351, + [3352] = 3352, + [3353] = 3353, + [3354] = 3331, + [3355] = 3345, + [3356] = 3338, + [3357] = 3357, + [3358] = 3358, + [3359] = 3359, + [3360] = 3360, + [3361] = 3361, + [3362] = 3330, + [3363] = 3363, + [3364] = 3364, + [3365] = 3326, + [3366] = 3327, + [3367] = 3367, + [3368] = 3368, + [3369] = 3369, + [3370] = 3363, + [3371] = 3371, + [3372] = 3372, + [3373] = 3373, + [3374] = 3374, + [3375] = 3375, + [3376] = 3376, + [3377] = 3377, + [3378] = 3378, + [3379] = 3379, + [3380] = 3380, + [3381] = 3336, + [3382] = 3340, + [3383] = 3358, + [3384] = 3364, + [3385] = 3385, + [3386] = 3386, + [3387] = 3330, + [3388] = 3388, + [3389] = 3389, + [3390] = 3390, + [3391] = 3391, + [3392] = 3392, + [3393] = 3330, + [3394] = 3394, + [3395] = 3333, + [3396] = 3353, + [3397] = 3331, + [3398] = 3398, + [3399] = 3338, + [3400] = 3400, + [3401] = 3401, + [3402] = 3402, + [3403] = 3326, + [3404] = 3327, + [3405] = 3330, + [3406] = 3406, + [3407] = 3407, + [3408] = 3363, + [3409] = 3374, + [3410] = 3410, + [3411] = 3376, + [3412] = 3377, + [3413] = 3388, + [3414] = 3379, + [3415] = 3336, + [3416] = 3340, + [3417] = 3358, + [3418] = 3364, + [3419] = 3419, + [3420] = 3420, + [3421] = 3421, + [3422] = 3422, + [3423] = 3338, + [3424] = 3424, + [3425] = 3425, + [3426] = 3326, + [3427] = 3327, + [3428] = 3374, + [3429] = 3429, + [3430] = 3376, + [3431] = 3325, + [3432] = 3432, + [3433] = 3433, + [3434] = 3338, + [3435] = 3435, + [3436] = 3436, + [3437] = 3326, + [3438] = 3327, + [3439] = 3439, + [3440] = 3376, + [3441] = 3376, + [3442] = 3442, + [3443] = 3338, + [3444] = 3345, + [3445] = 3326, + [3446] = 3327, + [3447] = 3376, + [3448] = 3448, + [3449] = 3348, + [3450] = 3326, + [3451] = 3327, + [3452] = 3376, + [3453] = 3453, + [3454] = 3454, + [3455] = 3326, + [3456] = 3327, + [3457] = 3376, + [3458] = 3331, + [3459] = 3459, + [3460] = 3326, + [3461] = 3327, + [3462] = 3376, + [3463] = 3463, + [3464] = 3326, + [3465] = 3327, + [3466] = 3376, + [3467] = 3345, + [3468] = 3377, + [3469] = 3469, + [3470] = 3326, + [3471] = 3379, + [3472] = 3472, + [3473] = 3473, + [3474] = 3474, + [3475] = 3327, + [3476] = 3348, + [3477] = 3477, + [3478] = 3478, + [3479] = 3479, + [3480] = 3374, + [3481] = 3481, + [3482] = 3482, + [3483] = 3483, + [3484] = 3484, + [3485] = 3485, + [3486] = 3376, + [3487] = 3487, + [3488] = 3488, + [3489] = 3353, + [3490] = 3331, + [3491] = 3491, + [3492] = 3338, + [3493] = 3353, + [3494] = 3494, + [3495] = 3495, + [3496] = 3496, + [3497] = 3367, + [3498] = 3498, + [3499] = 3499, + [3500] = 3500, + [3501] = 3501, + [3502] = 3502, + [3503] = 3503, + [3504] = 3504, + [3505] = 3353, + [3506] = 3377, + [3507] = 3330, + [3508] = 3508, + [3509] = 3509, + [3510] = 3510, + [3511] = 3511, + [3512] = 3363, + [3513] = 3364, + [3514] = 3514, + [3515] = 3515, + [3516] = 3516, + [3517] = 3331, + [3518] = 3518, + [3519] = 3338, + [3520] = 3520, + [3521] = 3367, + [3522] = 3326, + [3523] = 3368, + [3524] = 3327, + [3525] = 3326, + [3526] = 3336, + [3527] = 3340, + [3528] = 3327, + [3529] = 3348, + [3530] = 3530, + [3531] = 3345, + [3532] = 3532, + [3533] = 3533, + [3534] = 3388, + [3535] = 3390, + [3536] = 3363, + [3537] = 3537, + [3538] = 3367, + [3539] = 3539, + [3540] = 3540, + [3541] = 3516, + [3542] = 3542, + [3543] = 3543, + [3544] = 3544, + [3545] = 3545, + [3546] = 3358, + [3547] = 3547, + [3548] = 3388, + [3549] = 3333, + [3550] = 3472, + [3551] = 3551, + [3552] = 3333, + [3553] = 3553, + [3554] = 3340, + [3555] = 3353, + [3556] = 3556, + [3557] = 3407, + [3558] = 3407, + [3559] = 3559, + [3560] = 3560, + [3561] = 3561, + [3562] = 3338, + [3563] = 3563, + [3564] = 3564, + [3565] = 3565, + [3566] = 3374, + [3567] = 3567, + [3568] = 3568, + [3569] = 3364, + [3570] = 3570, + [3571] = 3571, + [3572] = 3572, + [3573] = 3573, + [3574] = 3376, + [3575] = 3374, + [3576] = 3576, + [3577] = 3377, + [3578] = 3578, + [3579] = 3579, + [3580] = 3580, + [3581] = 3571, + [3582] = 3379, + [3583] = 3379, + [3584] = 3584, + [3585] = 3350, + [3586] = 3586, + [3587] = 3587, + [3588] = 3588, + [3589] = 3589, + [3590] = 3358, + [3591] = 3363, + [3592] = 3348, + [3593] = 3593, + [3594] = 3514, + [3595] = 3595, + [3596] = 3596, + [3597] = 3597, + [3598] = 3598, + [3599] = 3599, + [3600] = 3376, + [3601] = 3407, + [3602] = 3602, + [3603] = 3603, + [3604] = 3604, + [3605] = 3390, + [3606] = 3606, + [3607] = 3607, + [3608] = 3608, + [3609] = 3336, + [3610] = 3340, + [3611] = 3329, + [3612] = 3612, + [3613] = 3613, + [3614] = 3614, + [3615] = 3615, + [3616] = 3616, + [3617] = 3617, + [3618] = 3329, + [3619] = 3619, + [3620] = 3377, + [3621] = 3621, + [3622] = 3329, + [3623] = 3379, + [3624] = 3358, + [3625] = 3625, + [3626] = 3626, + [3627] = 3627, + [3628] = 3364, + [3629] = 3629, + [3630] = 3540, + [3631] = 3631, + [3632] = 3632, + [3633] = 3633, + [3634] = 3634, + [3635] = 3635, + [3636] = 3636, + [3637] = 3637, + [3638] = 3638, + [3639] = 3639, +}; + +static const TSSymbol ts_supertype_symbols[SUPERTYPE_COUNT] = { + sym__literal, + sym__statement, +}; + +static const TSMapSlice ts_supertype_map_slices[] = { + [sym__literal] = {.index = 0, .length = 11}, + [sym__statement] = {.index = 11, .length = 16}, +}; + +static const TSSymbol ts_supertype_map_entries[] = { + [0] = + sym_decimal_floating_point_literal, + sym_decimal_integer_literal, + sym_false, + sym_hex_integer_literal, + sym_list_literal, + sym_null_literal, + sym_record_literal, + sym_set_or_map_literal, + sym_string_literal, + sym_symbol_literal, + sym_true, + [11] = + sym_assert_statement, + sym_block, + sym_break_statement, + sym_continue_statement, + sym_do_statement, + sym_expression_statement, + sym_for_statement, + sym_if_statement, + sym_local_function_declaration, + sym_local_variable_declaration, + sym_return_statement, + sym_switch_statement, + sym_try_statement, + sym_while_statement, + sym_yield_each_statement, + sym_yield_statement, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(103); + ADVANCE_MAP( + '!', 217, + '"', 112, + '#', 105, + '$', 119, + '%', 208, + '&', 189, + '\'', 114, + '(', 140, + ')', 141, + '*', 204, + '+', 198, + ',', 137, + '-', 215, + '.', 225, + '/', 206, + '0', 106, + ':', 139, + ';', 234, + '<', 174, + '=', 145, + '>', 180, + '?', 164, + '@', 236, + '[', 136, + '\\', 85, + ']', 138, + '^', 187, + 'a', 261, + 'p', 255, + 'r', 253, + 's', 265, + '{', 123, + '|', 184, + '}', 124, + '~', 219, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(99); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (('A' <= lookahead && lookahead <= '_') || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 1: + if (lookahead == '\n') ADVANCE(248); + if (lookahead == '/') ADVANCE(42); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(1); + END_STATE(); + case 2: + if (lookahead == '\n') SKIP(2); + if (lookahead == '/') ADVANCE(245); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(246); + if (lookahead != 0) ADVANCE(247); + END_STATE(); + case 3: + ADVANCE_MAP( + '!', 217, + '"', 112, + '#', 104, + '%', 207, + '&', 188, + '\'', 114, + '(', 140, + '*', 203, + '+', 197, + ',', 137, + '-', 214, + '.', 227, + '/', 205, + '0', 106, + ':', 139, + ';', 234, + '<', 175, + '=', 143, + '>', 181, + '?', 165, + '@', 236, + '[', 136, + '^', 186, + 'a', 262, + 'r', 253, + '{', 123, + '|', 185, + '}', 124, + '~', 220, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(3); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 4: + ADVANCE_MAP( + '!', 217, + '"', 112, + '#', 104, + '\'', 114, + '(', 140, + ')', 141, + '+', 48, + ',', 137, + '-', 214, + '.', 51, + '/', 42, + '0', 106, + ':', 139, + '<', 177, + '=', 56, + '>', 179, + '?', 162, + '@', 236, + '[', 136, + ']', 138, + 'r', 253, + '{', 123, + '~', 218, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(4); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 5: + ADVANCE_MAP( + '!', 217, + '"', 112, + '%', 207, + '&', 188, + '\'', 114, + '(', 140, + ')', 141, + '*', 203, + ',', 137, + '.', 224, + '/', 205, + ':', 139, + '<', 175, + '=', 57, + '>', 181, + '?', 169, + '[', 136, + ']', 138, + '^', 186, + 'a', 262, + 'r', 253, + '|', 185, + '}', 124, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(5); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 6: + ADVANCE_MAP( + '!', 217, + '"', 112, + '%', 207, + '&', 188, + '\'', 114, + '(', 140, + ')', 141, + '*', 203, + ',', 137, + '.', 226, + '/', 205, + ':', 139, + ';', 234, + '<', 175, + '=', 144, + '>', 181, + '?', 165, + '[', 136, + ']', 138, + '^', 186, + 'a', 262, + 'r', 253, + '{', 123, + '|', 185, + '}', 124, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(6); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 7: + ADVANCE_MAP( + '!', 217, + '"', 112, + '%', 207, + '&', 188, + '\'', 114, + '(', 140, + '*', 203, + ',', 137, + '.', 226, + '/', 205, + ';', 234, + '<', 175, + '=', 144, + '>', 181, + '?', 165, + '[', 136, + '^', 186, + 'a', 261, + 'r', 253, + 's', 265, + '{', 123, + '|', 185, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(7); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 8: + ADVANCE_MAP( + '!', 217, + '%', 208, + '&', 189, + '(', 140, + ')', 141, + '*', 204, + '+', 198, + ',', 137, + '-', 200, + '.', 224, + '/', 206, + ':', 139, + '<', 174, + '=', 144, + '>', 180, + '?', 168, + '[', 136, + ']', 138, + '^', 187, + 'a', 262, + '|', 184, + '}', 124, + '~', 52, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(8); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 9: + ADVANCE_MAP( + '!', 217, + '%', 208, + '&', 189, + '(', 140, + ')', 141, + '*', 204, + '+', 198, + ',', 137, + '-', 200, + '.', 226, + '/', 206, + ':', 139, + ';', 234, + '<', 174, + '=', 144, + '>', 180, + '?', 164, + '[', 136, + ']', 138, + '^', 187, + 'a', 262, + '|', 184, + '}', 124, + '~', 52, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(9); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 10: + ADVANCE_MAP( + '!', 217, + '%', 208, + '&', 189, + '(', 140, + ')', 141, + '*', 204, + '+', 201, + ',', 137, + '-', 202, + '.', 226, + '/', 206, + ':', 139, + ';', 234, + '<', 174, + '=', 144, + '>', 180, + '?', 164, + '[', 136, + ']', 138, + '^', 187, + 'a', 262, + '|', 184, + '}', 124, + '~', 52, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(10); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 11: + ADVANCE_MAP( + '!', 217, + '%', 208, + '&', 189, + '(', 140, + '*', 204, + '+', 198, + ',', 137, + '-', 200, + '.', 226, + '/', 206, + ';', 234, + '<', 174, + '=', 144, + '>', 180, + '?', 164, + '[', 136, + '^', 187, + 'a', 261, + 's', 265, + '{', 123, + '|', 184, + '~', 52, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(11); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 12: + ADVANCE_MAP( + '!', 217, + '%', 208, + '&', 189, + '(', 140, + '*', 204, + '+', 201, + ',', 137, + '-', 202, + '.', 226, + '/', 206, + ';', 234, + '<', 174, + '=', 144, + '>', 180, + '?', 164, + '[', 136, + '^', 187, + 'a', 261, + 's', 265, + '{', 123, + '|', 184, + '~', 52, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(12); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 13: + ADVANCE_MAP( + '!', 217, + '%', 207, + '&', 188, + '(', 140, + ')', 141, + '*', 203, + '+', 197, + ',', 137, + '-', 199, + '.', 224, + '/', 205, + ':', 139, + '<', 175, + '=', 57, + '>', 181, + '?', 169, + '[', 136, + ']', 138, + '^', 186, + 'a', 262, + '|', 185, + '}', 124, + '~', 53, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(13); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 14: + ADVANCE_MAP( + '!', 217, + '%', 207, + '&', 188, + '(', 140, + ')', 141, + '*', 203, + '+', 197, + ',', 137, + '-', 199, + '.', 226, + '/', 205, + ':', 139, + ';', 234, + '<', 175, + '=', 57, + '>', 181, + '?', 165, + '[', 136, + ']', 138, + '^', 186, + 'a', 262, + '|', 185, + '}', 124, + '~', 53, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(14); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 15: + ADVANCE_MAP( + '!', 217, + '%', 207, + '&', 188, + '(', 140, + '*', 203, + '+', 197, + ',', 137, + '-', 199, + '.', 226, + '/', 205, + ';', 234, + '<', 175, + '=', 57, + '>', 181, + '?', 165, + '[', 136, + '^', 186, + 'a', 261, + 's', 265, + '{', 123, + '|', 185, + '~', 53, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(15); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 16: + if (lookahead == '!') ADVANCE(244); + END_STATE(); + case 17: + ADVANCE_MAP( + '!', 216, + '"', 112, + '$', 118, + '\'', 113, + '(', 140, + ',', 137, + '.', 226, + '/', 42, + ';', 234, + '<', 173, + '=', 71, + '?', 163, + '[', 136, + '\\', 85, + 'a', 84, + 's', 86, + '{', 123, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(18); + END_STATE(); + case 18: + ADVANCE_MAP( + '!', 216, + '"', 112, + '$', 118, + '\'', 113, + '(', 140, + ',', 137, + '.', 226, + '/', 42, + ';', 234, + '<', 173, + '=', 71, + '?', 163, + '[', 136, + 'a', 84, + 's', 86, + '{', 123, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(18); + END_STATE(); + case 19: + ADVANCE_MAP( + '!', 216, + '"', 112, + '%', 207, + '&', 188, + '\'', 114, + '(', 140, + ')', 141, + '*', 203, + ',', 137, + '.', 224, + '/', 205, + ':', 139, + '<', 175, + '=', 63, + '>', 181, + '?', 162, + '[', 73, + ']', 138, + '^', 186, + 'a', 262, + 'r', 253, + '|', 185, + '}', 124, + '~', 220, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(19); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 20: + ADVANCE_MAP( + '!', 216, + '"', 111, + '$', 118, + '&', 37, + '\'', 114, + ')', 141, + ',', 137, + '/', 42, + '=', 142, + '?', 162, + '\\', 85, + ']', 138, + 'a', 83, + '|', 89, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(21); + END_STATE(); + case 21: + ADVANCE_MAP( + '!', 216, + '"', 111, + '$', 118, + '&', 37, + '\'', 114, + ')', 141, + ',', 137, + '/', 42, + '=', 142, + '?', 162, + ']', 138, + 'a', 83, + '|', 89, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(21); + END_STATE(); + case 22: + ADVANCE_MAP( + '!', 216, + '%', 58, + '&', 59, + '(', 140, + ')', 141, + '*', 60, + '+', 61, + ',', 137, + '-', 62, + '.', 226, + '/', 43, + ':', 139, + ';', 234, + '<', 176, + '=', 146, + '>', 72, + '?', 166, + '[', 136, + ']', 138, + '^', 64, + 'a', 263, + 's', 265, + '{', 123, + '|', 65, + '}', 124, + '~', 55, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(22); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 23: + ADVANCE_MAP( + '!', 216, + '%', 58, + '&', 59, + '(', 140, + ')', 141, + '*', 60, + '+', 61, + ',', 137, + '-', 62, + '.', 226, + '/', 43, + ':', 139, + ';', 234, + '<', 176, + '=', 146, + '>', 72, + '?', 166, + '[', 136, + ']', 138, + '^', 64, + '|', 65, + '}', 124, + '~', 55, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(23); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 24: + ADVANCE_MAP( + '!', 216, + '&', 37, + '(', 140, + ')', 141, + ',', 137, + '.', 224, + '/', 42, + ':', 139, + '<', 173, + '=', 146, + '?', 162, + ']', 138, + 'a', 262, + '|', 89, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(24); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 25: + ADVANCE_MAP( + '!', 56, + '"', 112, + '#', 104, + '\'', 114, + '(', 140, + ')', 141, + ',', 137, + '-', 213, + '.', 51, + '/', 42, + '0', 106, + ':', 139, + '<', 177, + '=', 56, + '>', 179, + '@', 236, + '[', 136, + ']', 138, + 'r', 253, + '{', 123, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(25); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 26: + ADVANCE_MAP( + '!', 56, + '%', 207, + '&', 188, + '(', 140, + ')', 141, + '*', 203, + ',', 137, + '.', 224, + '/', 205, + ':', 139, + '<', 175, + '=', 57, + '>', 181, + '?', 171, + ']', 138, + '^', 186, + 'a', 262, + '|', 185, + '}', 124, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(26); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 27: + ADVANCE_MAP( + '!', 56, + '%', 207, + '&', 188, + '(', 140, + ')', 141, + '*', 203, + ',', 137, + '.', 226, + '/', 205, + ':', 139, + ';', 234, + '<', 175, + '=', 57, + '>', 181, + '?', 170, + '[', 136, + ']', 138, + '^', 186, + 'a', 262, + '|', 185, + '}', 124, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(27); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 28: + ADVANCE_MAP( + '!', 56, + '%', 207, + '&', 188, + '(', 140, + '*', 203, + ',', 137, + '.', 226, + '/', 205, + ';', 234, + '<', 175, + '=', 57, + '>', 181, + '?', 170, + '^', 186, + 'a', 261, + 's', 265, + '{', 123, + '|', 185, + '~', 53, + '+', 196, + '-', 196, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(28); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 29: + if (lookahead == '"') ADVANCE(112); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(130); + if (lookahead == '\\') ADVANCE(132); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(126); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 30: + if (lookahead == '"') ADVANCE(115); + END_STATE(); + case 31: + if (lookahead == '"') ADVANCE(121); + END_STATE(); + case 32: + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(114); + if (lookahead == '/') ADVANCE(130); + if (lookahead == '\\') ADVANCE(132); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(127); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 33: + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(42); + if (lookahead == '\\') ADVANCE(85); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(34); + END_STATE(); + case 34: + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(42); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(34); + END_STATE(); + case 35: + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(130); + if (lookahead == '\\') ADVANCE(132); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(128); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 36: + if (lookahead == '$') ADVANCE(268); + END_STATE(); + case 37: + if (lookahead == '&') ADVANCE(250); + END_STATE(); + case 38: + ADVANCE_MAP( + '&', 37, + '(', 140, + ')', 141, + ',', 137, + '.', 224, + '/', 42, + ':', 139, + ';', 234, + '<', 173, + '=', 146, + '>', 178, + '?', 162, + '@', 236, + '[', 136, + ']', 138, + '{', 123, + '|', 89, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(38); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 39: + if (lookahead == '\'') ADVANCE(116); + END_STATE(); + case 40: + if (lookahead == '\'') ADVANCE(122); + END_STATE(); + case 41: + ADVANCE_MAP( + ')', 141, + ',', 137, + '/', 42, + ':', 139, + ';', 234, + '=', 146, + '?', 162, + ']', 138, + 'a', 263, + 's', 265, + '{', 123, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(41); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 42: + if (lookahead == '*') ADVANCE(278); + if (lookahead == '/') ADVANCE(270); + END_STATE(); + case 43: + if (lookahead == '*') ADVANCE(278); + if (lookahead == '/') ADVANCE(270); + if (lookahead == '=') ADVANCE(150); + END_STATE(); + case 44: + if (lookahead == '*') ADVANCE(243); + END_STATE(); + case 45: + if (lookahead == '*') ADVANCE(283); + if (lookahead == '/') ADVANCE(47); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(45); + if (lookahead != 0) ADVANCE(46); + END_STATE(); + case 46: + if (lookahead == '*') ADVANCE(283); + if (lookahead != 0) ADVANCE(46); + END_STATE(); + case 47: + if (lookahead == '*') ADVANCE(279); + if (lookahead == '/') ADVANCE(269); + if (lookahead != 0) ADVANCE(46); + END_STATE(); + case 48: + if (lookahead == '+') ADVANCE(211); + END_STATE(); + case 49: + if (lookahead == '.') ADVANCE(212); + END_STATE(); + case 50: + if (lookahead == '.') ADVANCE(231); + END_STATE(); + case 51: + if (lookahead == '.') ADVANCE(49); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 52: + if (lookahead == '/') ADVANCE(210); + END_STATE(); + case 53: + if (lookahead == '/') ADVANCE(209); + END_STATE(); + case 54: + if (lookahead == '/') ADVANCE(130); + if (lookahead == '\\') ADVANCE(129); + if (lookahead == '{') ADVANCE(123); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(131); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(268); + if (lookahead != 0) ADVANCE(125); + END_STATE(); + case 55: + if (lookahead == '/') ADVANCE(69); + END_STATE(); + case 56: + if (lookahead == '=') ADVANCE(172); + END_STATE(); + case 57: + if (lookahead == '=') ADVANCE(172); + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 58: + if (lookahead == '=') ADVANCE(151); + END_STATE(); + case 59: + if (lookahead == '=') ADVANCE(156); + END_STATE(); + case 60: + if (lookahead == '=') ADVANCE(149); + END_STATE(); + case 61: + if (lookahead == '=') ADVANCE(147); + END_STATE(); + case 62: + if (lookahead == '=') ADVANCE(148); + END_STATE(); + case 63: + if (lookahead == '=') ADVANCE(237); + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 64: + if (lookahead == '=') ADVANCE(157); + END_STATE(); + case 65: + if (lookahead == '=') ADVANCE(158); + END_STATE(); + case 66: + if (lookahead == '=') ADVANCE(153); + END_STATE(); + case 67: + if (lookahead == '=') ADVANCE(154); + if (lookahead == '>') ADVANCE(70); + END_STATE(); + case 68: + if (lookahead == '=') ADVANCE(159); + END_STATE(); + case 69: + if (lookahead == '=') ADVANCE(152); + END_STATE(); + case 70: + if (lookahead == '=') ADVANCE(155); + END_STATE(); + case 71: + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 72: + if (lookahead == '>') ADVANCE(67); + END_STATE(); + case 73: + if (lookahead == ']') ADVANCE(238); + END_STATE(); + case 74: + if (lookahead == '_') ADVANCE(74); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(107); + END_STATE(); + case 75: + if (lookahead == '_') ADVANCE(75); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 76: + if (lookahead == '_') ADVANCE(76); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 77: + if (lookahead == 'c') ADVANCE(44); + END_STATE(); + case 78: + if (lookahead == 'c') ADVANCE(240); + END_STATE(); + case 79: + if (lookahead == 'f') ADVANCE(249); + END_STATE(); + case 80: + if (lookahead == 'n') ADVANCE(77); + END_STATE(); + case 81: + if (lookahead == 'n') ADVANCE(78); + END_STATE(); + case 82: + if (lookahead == 'o') ADVANCE(79); + END_STATE(); + case 83: + if (lookahead == 's') ADVANCE(221); + END_STATE(); + case 84: + if (lookahead == 's') ADVANCE(87); + END_STATE(); + case 85: + if (lookahead == 'u') ADVANCE(88); + if (lookahead == 'x') ADVANCE(98); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(135); + if (lookahead != 0) ADVANCE(133); + END_STATE(); + case 86: + if (lookahead == 'y') ADVANCE(80); + END_STATE(); + case 87: + if (lookahead == 'y') ADVANCE(81); + END_STATE(); + case 88: + if (lookahead == '{') ADVANCE(96); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(97); + END_STATE(); + case 89: + if (lookahead == '|') ADVANCE(251); + END_STATE(); + case 90: + if (lookahead == '}') ADVANCE(133); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(90); + END_STATE(); + case 91: + if (lookahead == '+' || + lookahead == '-') ADVANCE(93); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 92: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 93: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 94: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(133); + END_STATE(); + case 95: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(108); + END_STATE(); + case 96: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(90); + END_STATE(); + case 97: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(98); + END_STATE(); + case 98: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(94); + END_STATE(); + case 99: + if (eof) ADVANCE(103); + ADVANCE_MAP( + '!', 217, + '"', 112, + '#', 105, + '$', 119, + '%', 208, + '&', 189, + '\'', 114, + '(', 140, + ')', 141, + '*', 204, + '+', 198, + ',', 137, + '-', 215, + '.', 225, + '/', 206, + '0', 106, + ':', 139, + ';', 234, + '<', 174, + '=', 145, + '>', 180, + '?', 164, + '@', 236, + '[', 136, + ']', 138, + '^', 187, + 'a', 261, + 'p', 255, + 'r', 253, + 's', 265, + '{', 123, + '|', 184, + '}', 124, + '~', 219, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(99); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 100: + if (eof) ADVANCE(103); + ADVANCE_MAP( + '!', 216, + '"', 112, + '#', 16, + '\'', 114, + '(', 140, + ')', 141, + ',', 137, + '.', 224, + '/', 42, + ':', 139, + ';', 234, + '<', 173, + '=', 142, + '>', 178, + '?', 167, + '@', 236, + '[', 136, + ']', 138, + 'p', 255, + 'r', 253, + '}', 124, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(100); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 101: + if (eof) ADVANCE(103); + ADVANCE_MAP( + '!', 216, + '"', 112, + '#', 104, + '&', 37, + '\'', 114, + '(', 140, + ')', 141, + '*', 203, + '+', 48, + ',', 137, + '-', 214, + '.', 51, + '/', 42, + '0', 106, + ':', 139, + ';', 234, + '<', 173, + '=', 146, + '>', 178, + '?', 162, + '@', 236, + '[', 136, + ']', 138, + 'r', 253, + '{', 123, + '|', 89, + '}', 124, + '~', 218, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(101); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 102: + if (eof) ADVANCE(103); + ADVANCE_MAP( + '!', 216, + '"', 112, + '#', 104, + '&', 37, + '\'', 114, + '(', 140, + ')', 141, + '+', 48, + ',', 137, + '-', 214, + '.', 228, + '/', 42, + '0', 106, + ':', 139, + ';', 234, + '<', 173, + '=', 63, + '>', 178, + '?', 167, + '@', 236, + '[', 136, + ']', 138, + 'r', 253, + '{', 123, + '|', 89, + '}', 124, + '~', 218, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(102); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(107); + if (lookahead == '$' || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 103: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 104: + ACCEPT_TOKEN(anon_sym_POUND); + END_STATE(); + case 105: + ACCEPT_TOKEN(anon_sym_POUND); + if (lookahead == '!') ADVANCE(244); + END_STATE(); + case 106: + ACCEPT_TOKEN(sym_decimal_integer_literal); + if (lookahead == '.') ADVANCE(92); + if (lookahead == '_') ADVANCE(74); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(91); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(95); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(107); + END_STATE(); + case 107: + ACCEPT_TOKEN(sym_decimal_integer_literal); + if (lookahead == '.') ADVANCE(92); + if (lookahead == '_') ADVANCE(74); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(107); + END_STATE(); + case 108: + ACCEPT_TOKEN(sym_hex_integer_literal); + if (lookahead == '_') ADVANCE(95); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(108); + END_STATE(); + case 109: + ACCEPT_TOKEN(sym_decimal_floating_point_literal); + if (lookahead == '_') ADVANCE(75); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(91); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 110: + ACCEPT_TOKEN(sym_decimal_floating_point_literal); + if (lookahead == '_') ADVANCE(76); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 111: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 112: + ACCEPT_TOKEN(anon_sym_DQUOTE); + if (lookahead == '"') ADVANCE(30); + END_STATE(); + case 113: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 114: + ACCEPT_TOKEN(anon_sym_SQUOTE); + if (lookahead == '\'') ADVANCE(39); + END_STATE(); + case 115: + ACCEPT_TOKEN(anon_sym_DQUOTE_DQUOTE_DQUOTE); + END_STATE(); + case 116: + ACCEPT_TOKEN(anon_sym_SQUOTE_SQUOTE_SQUOTE); + END_STATE(); + case 117: + ACCEPT_TOKEN(anon_sym_r_DQUOTE); + if (lookahead == '"') ADVANCE(31); + END_STATE(); + case 118: + ACCEPT_TOKEN(anon_sym_DOLLAR); + END_STATE(); + case 119: + ACCEPT_TOKEN(anon_sym_DOLLAR); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 120: + ACCEPT_TOKEN(anon_sym_r_SQUOTE); + if (lookahead == '\'') ADVANCE(40); + END_STATE(); + case 121: + ACCEPT_TOKEN(anon_sym_r_DQUOTE_DQUOTE_DQUOTE); + END_STATE(); + case 122: + ACCEPT_TOKEN(anon_sym_r_SQUOTE_SQUOTE_SQUOTE); + END_STATE(); + case 123: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 124: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 125: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + END_STATE(); + case 126: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '"') ADVANCE(112); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(130); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(126); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 127: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(114); + if (lookahead == '/') ADVANCE(130); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(127); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 128: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '"') ADVANCE(111); + if (lookahead == '$') ADVANCE(118); + if (lookahead == '\'') ADVANCE(113); + if (lookahead == '/') ADVANCE(130); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(128); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 129: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '$') ADVANCE(268); + END_STATE(); + case 130: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '*') ADVANCE(278); + if (lookahead == '/') ADVANCE(270); + END_STATE(); + case 131: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == '/') ADVANCE(130); + if (lookahead == '\\') ADVANCE(129); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(131); + if (lookahead != 0 && + (lookahead < 'A' || 'Z' < lookahead) && + lookahead != '_' && + (lookahead < 'a' || '{' < lookahead)) ADVANCE(125); + END_STATE(); + case 132: + ACCEPT_TOKEN(aux_sym__sub_string_test_token1); + if (lookahead == 'u') ADVANCE(88); + if (lookahead == 'x') ADVANCE(98); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(135); + if (lookahead != 0) ADVANCE(133); + END_STATE(); + case 133: + ACCEPT_TOKEN(sym__unused_escape_sequence); + END_STATE(); + case 134: + ACCEPT_TOKEN(sym__unused_escape_sequence); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(133); + END_STATE(); + case 135: + ACCEPT_TOKEN(sym__unused_escape_sequence); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(134); + END_STATE(); + case 136: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 137: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 138: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 139: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 140: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 141: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 142: + ACCEPT_TOKEN(anon_sym_EQ); + END_STATE(); + case 143: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(172); + END_STATE(); + case 144: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(172); + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 145: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(237); + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 146: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '>') ADVANCE(235); + END_STATE(); + case 147: + ACCEPT_TOKEN(anon_sym_PLUS_EQ); + END_STATE(); + case 148: + ACCEPT_TOKEN(anon_sym_DASH_EQ); + END_STATE(); + case 149: + ACCEPT_TOKEN(anon_sym_STAR_EQ); + END_STATE(); + case 150: + ACCEPT_TOKEN(anon_sym_SLASH_EQ); + END_STATE(); + case 151: + ACCEPT_TOKEN(anon_sym_PERCENT_EQ); + END_STATE(); + case 152: + ACCEPT_TOKEN(anon_sym_TILDE_SLASH_EQ); + END_STATE(); + case 153: + ACCEPT_TOKEN(anon_sym_LT_LT_EQ); + END_STATE(); + case 154: + ACCEPT_TOKEN(anon_sym_GT_GT_EQ); + END_STATE(); + case 155: + ACCEPT_TOKEN(anon_sym_GT_GT_GT_EQ); + END_STATE(); + case 156: + ACCEPT_TOKEN(anon_sym_AMP_EQ); + END_STATE(); + case 157: + ACCEPT_TOKEN(anon_sym_CARET_EQ); + END_STATE(); + case 158: + ACCEPT_TOKEN(anon_sym_PIPE_EQ); + END_STATE(); + case 159: + ACCEPT_TOKEN(anon_sym_QMARK_QMARK_EQ); + END_STATE(); + case 160: + ACCEPT_TOKEN(anon_sym_QMARK_QMARK); + END_STATE(); + case 161: + ACCEPT_TOKEN(anon_sym_QMARK_QMARK); + if (lookahead == '=') ADVANCE(159); + END_STATE(); + case 162: + ACCEPT_TOKEN(anon_sym_QMARK); + END_STATE(); + case 163: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(233); + END_STATE(); + case 164: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(233); + if (lookahead == '?') ADVANCE(161); + END_STATE(); + case 165: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(233); + if (lookahead == '?') ADVANCE(160); + END_STATE(); + case 166: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(233); + if (lookahead == '?') ADVANCE(68); + END_STATE(); + case 167: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(232); + END_STATE(); + case 168: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(232); + if (lookahead == '?') ADVANCE(161); + END_STATE(); + case 169: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(232); + if (lookahead == '?') ADVANCE(160); + END_STATE(); + case 170: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '.') ADVANCE(50); + if (lookahead == '?') ADVANCE(160); + END_STATE(); + case 171: + ACCEPT_TOKEN(anon_sym_QMARK); + if (lookahead == '?') ADVANCE(160); + END_STATE(); + case 172: + ACCEPT_TOKEN(sym_equality_operator); + END_STATE(); + case 173: + ACCEPT_TOKEN(anon_sym_LT); + END_STATE(); + case 174: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(191); + if (lookahead == '=') ADVANCE(182); + END_STATE(); + case 175: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(190); + if (lookahead == '=') ADVANCE(182); + END_STATE(); + case 176: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(66); + END_STATE(); + case 177: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '=') ADVANCE(182); + END_STATE(); + case 178: + ACCEPT_TOKEN(anon_sym_GT); + END_STATE(); + case 179: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(183); + END_STATE(); + case 180: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(183); + if (lookahead == '>') ADVANCE(192); + END_STATE(); + case 181: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(183); + if (lookahead == '>') ADVANCE(193); + END_STATE(); + case 182: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 183: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 184: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '=') ADVANCE(158); + if (lookahead == '|') ADVANCE(251); + END_STATE(); + case 185: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(251); + END_STATE(); + case 186: + ACCEPT_TOKEN(anon_sym_CARET); + END_STATE(); + case 187: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '=') ADVANCE(157); + END_STATE(); + case 188: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(250); + END_STATE(); + case 189: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(250); + if (lookahead == '=') ADVANCE(156); + END_STATE(); + case 190: + ACCEPT_TOKEN(anon_sym_LT_LT); + END_STATE(); + case 191: + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '=') ADVANCE(153); + END_STATE(); + case 192: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '=') ADVANCE(154); + if (lookahead == '>') ADVANCE(195); + END_STATE(); + case 193: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '>') ADVANCE(194); + END_STATE(); + case 194: + ACCEPT_TOKEN(anon_sym_GT_GT_GT); + END_STATE(); + case 195: + ACCEPT_TOKEN(anon_sym_GT_GT_GT); + if (lookahead == '=') ADVANCE(155); + END_STATE(); + case 196: + ACCEPT_TOKEN(sym__additive_operator); + END_STATE(); + case 197: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '+') ADVANCE(211); + END_STATE(); + case 198: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '+') ADVANCE(211); + if (lookahead == '=') ADVANCE(147); + END_STATE(); + case 199: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '-') ADVANCE(211); + END_STATE(); + case 200: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '-') ADVANCE(211); + if (lookahead == '=') ADVANCE(148); + END_STATE(); + case 201: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '=') ADVANCE(147); + END_STATE(); + case 202: + ACCEPT_TOKEN(sym__additive_operator); + if (lookahead == '=') ADVANCE(148); + END_STATE(); + case 203: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 204: + ACCEPT_TOKEN(anon_sym_STAR); + if (lookahead == '=') ADVANCE(149); + END_STATE(); + case 205: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '*') ADVANCE(278); + if (lookahead == '/') ADVANCE(270); + END_STATE(); + case 206: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '*') ADVANCE(278); + if (lookahead == '/') ADVANCE(270); + if (lookahead == '=') ADVANCE(150); + END_STATE(); + case 207: + ACCEPT_TOKEN(anon_sym_PERCENT); + END_STATE(); + case 208: + ACCEPT_TOKEN(anon_sym_PERCENT); + if (lookahead == '=') ADVANCE(151); + END_STATE(); + case 209: + ACCEPT_TOKEN(anon_sym_TILDE_SLASH); + END_STATE(); + case 210: + ACCEPT_TOKEN(anon_sym_TILDE_SLASH); + if (lookahead == '=') ADVANCE(152); + END_STATE(); + case 211: + ACCEPT_TOKEN(sym_increment_operator); + END_STATE(); + case 212: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 213: + ACCEPT_TOKEN(sym_minus_operator); + END_STATE(); + case 214: + ACCEPT_TOKEN(sym_minus_operator); + if (lookahead == '-') ADVANCE(211); + END_STATE(); + case 215: + ACCEPT_TOKEN(sym_minus_operator); + if (lookahead == '-') ADVANCE(211); + if (lookahead == '=') ADVANCE(148); + END_STATE(); + case 216: + ACCEPT_TOKEN(anon_sym_BANG); + END_STATE(); + case 217: + ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(172); + END_STATE(); + case 218: + ACCEPT_TOKEN(anon_sym_TILDE); + END_STATE(); + case 219: + ACCEPT_TOKEN(anon_sym_TILDE); + if (lookahead == '/') ADVANCE(210); + END_STATE(); + case 220: + ACCEPT_TOKEN(anon_sym_TILDE); + if (lookahead == '/') ADVANCE(209); + END_STATE(); + case 221: + ACCEPT_TOKEN(anon_sym_as); + END_STATE(); + case 222: + ACCEPT_TOKEN(anon_sym_as); + if (lookahead == 'y') ADVANCE(259); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 223: + ACCEPT_TOKEN(anon_sym_as); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 224: + ACCEPT_TOKEN(anon_sym_DOT); + END_STATE(); + case 225: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(230); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 226: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(229); + END_STATE(); + case 227: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(229); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 228: + ACCEPT_TOKEN(anon_sym_DOT); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 229: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + END_STATE(); + case 230: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '.') ADVANCE(212); + END_STATE(); + case 231: + ACCEPT_TOKEN(anon_sym_QMARK_DOT_DOT); + END_STATE(); + case 232: + ACCEPT_TOKEN(anon_sym_QMARK_DOT); + END_STATE(); + case 233: + ACCEPT_TOKEN(anon_sym_QMARK_DOT); + if (lookahead == '.') ADVANCE(231); + END_STATE(); + case 234: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 235: + ACCEPT_TOKEN(anon_sym_EQ_GT); + END_STATE(); + case 236: + ACCEPT_TOKEN(anon_sym_AT); + END_STATE(); + case 237: + ACCEPT_TOKEN(anon_sym_EQ_EQ); + END_STATE(); + case 238: + ACCEPT_TOKEN(anon_sym_LBRACK_RBRACK); + if (lookahead == '=') ADVANCE(239); + END_STATE(); + case 239: + ACCEPT_TOKEN(anon_sym_LBRACK_RBRACK_EQ); + END_STATE(); + case 240: + ACCEPT_TOKEN(anon_sym_async); + if (lookahead == '*') ADVANCE(242); + END_STATE(); + case 241: + ACCEPT_TOKEN(anon_sym_async); + if (lookahead == '*') ADVANCE(242); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 242: + ACCEPT_TOKEN(anon_sym_async_STAR); + END_STATE(); + case 243: + ACCEPT_TOKEN(anon_sym_sync_STAR); + END_STATE(); + case 244: + ACCEPT_TOKEN(anon_sym_POUND_BANG); + END_STATE(); + case 245: + ACCEPT_TOKEN(aux_sym_script_tag_token1); + if (lookahead == '*') ADVANCE(282); + if (lookahead == '/') ADVANCE(273); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(247); + END_STATE(); + case 246: + ACCEPT_TOKEN(aux_sym_script_tag_token1); + if (lookahead == '/') ADVANCE(245); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(246); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(247); + END_STATE(); + case 247: + ACCEPT_TOKEN(aux_sym_script_tag_token1); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(247); + END_STATE(); + case 248: + ACCEPT_TOKEN(anon_sym_LF); + if (lookahead == '\n') ADVANCE(248); + END_STATE(); + case 249: + ACCEPT_TOKEN(sym_part_of_builtin); + END_STATE(); + case 250: + ACCEPT_TOKEN(anon_sym_AMP_AMP); + END_STATE(); + case 251: + ACCEPT_TOKEN(anon_sym_PIPE_PIPE); + END_STATE(); + case 252: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == ' ') ADVANCE(82); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 253: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '"') ADVANCE(117); + if (lookahead == '\'') ADVANCE(120); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 254: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '*') ADVANCE(243); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 255: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(260); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 256: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'c') ADVANCE(254); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 257: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'c') ADVANCE(241); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 258: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(256); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 259: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(257); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 260: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(264); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 261: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 's') ADVANCE(222); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 262: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 's') ADVANCE(223); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 263: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 's') ADVANCE(266); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 264: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(252); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 265: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'y') ADVANCE(258); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 266: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'y') ADVANCE(259); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 267: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '$' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(267); + END_STATE(); + case 268: + ACCEPT_TOKEN(sym_identifier_dollar_escaped); + if (lookahead == '\\') ADVANCE(36); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(268); + END_STATE(); + case 269: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + if (lookahead == '*') ADVANCE(283); + if (lookahead == '/') ADVANCE(285); + if (lookahead != 0) ADVANCE(46); + END_STATE(); + case 270: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + if (lookahead == '/') ADVANCE(284); + END_STATE(); + case 271: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + if (lookahead == '/') ADVANCE(286); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(291); + END_STATE(); + case 272: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + if (lookahead == '/') ADVANCE(287); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(277); + END_STATE(); + case 273: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH); + if (lookahead == '/') ADVANCE(288); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(247); + END_STATE(); + case 274: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '*') ADVANCE(281); + if (lookahead == '/') ADVANCE(272); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(277); + END_STATE(); + case 275: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '/') ADVANCE(274); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(275); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(277); + END_STATE(); + case 276: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(275); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != '/') ADVANCE(277); + END_STATE(); + case 277: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(277); + END_STATE(); + case 278: + ACCEPT_TOKEN(anon_sym_SLASH_STAR); + END_STATE(); + case 279: + ACCEPT_TOKEN(anon_sym_SLASH_STAR); + if (lookahead == '*') ADVANCE(283); + if (lookahead != 0 && + lookahead != '/') ADVANCE(46); + END_STATE(); + case 280: + ACCEPT_TOKEN(anon_sym_SLASH_STAR); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(291); + END_STATE(); + case 281: + ACCEPT_TOKEN(anon_sym_SLASH_STAR); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(277); + END_STATE(); + case 282: + ACCEPT_TOKEN(anon_sym_SLASH_STAR); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(247); + END_STATE(); + case 283: + ACCEPT_TOKEN(aux_sym_comment_token2); + if (lookahead == '*') ADVANCE(283); + if (lookahead != 0 && + lookahead != '/') ADVANCE(46); + END_STATE(); + case 284: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH_SLASH); + END_STATE(); + case 285: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH_SLASH); + if (lookahead == '*') ADVANCE(283); + if (lookahead != 0) ADVANCE(46); + END_STATE(); + case 286: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH_SLASH); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(291); + END_STATE(); + case 287: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH_SLASH); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(277); + END_STATE(); + case 288: + ACCEPT_TOKEN(anon_sym_SLASH_SLASH_SLASH); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(247); + END_STATE(); + case 289: + ACCEPT_TOKEN(aux_sym_documentation_comment_token1); + if (lookahead == '*') ADVANCE(280); + if (lookahead == '/') ADVANCE(271); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(291); + END_STATE(); + case 290: + ACCEPT_TOKEN(aux_sym_documentation_comment_token1); + if (lookahead == '/') ADVANCE(289); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(290); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead)) ADVANCE(291); + END_STATE(); + case 291: + ACCEPT_TOKEN(aux_sym_documentation_comment_token1); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(291); + END_STATE(); + default: + return false; + } +} + +static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + ADVANCE_MAP( + 'F', 1, + 'a', 2, + 'b', 3, + 'c', 4, + 'd', 5, + 'e', 6, + 'f', 7, + 'g', 8, + 'h', 9, + 'i', 10, + 'l', 11, + 'm', 12, + 'n', 13, + 'o', 14, + 'p', 15, + 'r', 16, + 's', 17, + 't', 18, + 'v', 19, + 'w', 20, + 'y', 21, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + END_STATE(); + case 1: + if (lookahead == 'u') ADVANCE(22); + END_STATE(); + case 2: + if (lookahead == 'b') ADVANCE(23); + if (lookahead == 's') ADVANCE(24); + if (lookahead == 'w') ADVANCE(25); + END_STATE(); + case 3: + if (lookahead == 'a') ADVANCE(26); + if (lookahead == 'r') ADVANCE(27); + END_STATE(); + case 4: + if (lookahead == 'a') ADVANCE(28); + if (lookahead == 'l') ADVANCE(29); + if (lookahead == 'o') ADVANCE(30); + END_STATE(); + case 5: + if (lookahead == 'e') ADVANCE(31); + if (lookahead == 'o') ADVANCE(32); + END_STATE(); + case 6: + if (lookahead == 'l') ADVANCE(33); + if (lookahead == 'n') ADVANCE(34); + if (lookahead == 'x') ADVANCE(35); + END_STATE(); + case 7: + if (lookahead == 'a') ADVANCE(36); + if (lookahead == 'i') ADVANCE(37); + if (lookahead == 'o') ADVANCE(38); + END_STATE(); + case 8: + if (lookahead == 'e') ADVANCE(39); + END_STATE(); + case 9: + if (lookahead == 'i') ADVANCE(40); + END_STATE(); + case 10: + if (lookahead == 'f') ADVANCE(41); + if (lookahead == 'm') ADVANCE(42); + if (lookahead == 'n') ADVANCE(43); + if (lookahead == 's') ADVANCE(44); + END_STATE(); + case 11: + if (lookahead == 'a') ADVANCE(45); + if (lookahead == 'i') ADVANCE(46); + END_STATE(); + case 12: + if (lookahead == 'i') ADVANCE(47); + END_STATE(); + case 13: + if (lookahead == 'a') ADVANCE(48); + if (lookahead == 'e') ADVANCE(49); + if (lookahead == 'u') ADVANCE(50); + END_STATE(); + case 14: + if (lookahead == 'n') ADVANCE(51); + if (lookahead == 'p') ADVANCE(52); + END_STATE(); + case 15: + if (lookahead == 'a') ADVANCE(53); + END_STATE(); + case 16: + if (lookahead == 'e') ADVANCE(54); + END_STATE(); + case 17: + if (lookahead == 'e') ADVANCE(55); + if (lookahead == 'h') ADVANCE(56); + if (lookahead == 't') ADVANCE(57); + if (lookahead == 'u') ADVANCE(58); + if (lookahead == 'w') ADVANCE(59); + END_STATE(); + case 18: + if (lookahead == 'h') ADVANCE(60); + if (lookahead == 'r') ADVANCE(61); + if (lookahead == 'y') ADVANCE(62); + END_STATE(); + case 19: + if (lookahead == 'a') ADVANCE(63); + if (lookahead == 'o') ADVANCE(64); + END_STATE(); + case 20: + if (lookahead == 'h') ADVANCE(65); + if (lookahead == 'i') ADVANCE(66); + END_STATE(); + case 21: + if (lookahead == 'i') ADVANCE(67); + END_STATE(); + case 22: + if (lookahead == 'n') ADVANCE(68); + END_STATE(); + case 23: + if (lookahead == 's') ADVANCE(69); + END_STATE(); + case 24: + if (lookahead == 's') ADVANCE(70); + END_STATE(); + case 25: + if (lookahead == 'a') ADVANCE(71); + END_STATE(); + case 26: + if (lookahead == 's') ADVANCE(72); + END_STATE(); + case 27: + if (lookahead == 'e') ADVANCE(73); + END_STATE(); + case 28: + if (lookahead == 's') ADVANCE(74); + if (lookahead == 't') ADVANCE(75); + END_STATE(); + case 29: + if (lookahead == 'a') ADVANCE(76); + END_STATE(); + case 30: + if (lookahead == 'n') ADVANCE(77); + if (lookahead == 'v') ADVANCE(78); + END_STATE(); + case 31: + if (lookahead == 'f') ADVANCE(79); + END_STATE(); + case 32: + ACCEPT_TOKEN(anon_sym_do); + END_STATE(); + case 33: + if (lookahead == 's') ADVANCE(80); + END_STATE(); + case 34: + if (lookahead == 'u') ADVANCE(81); + END_STATE(); + case 35: + if (lookahead == 'p') ADVANCE(82); + if (lookahead == 't') ADVANCE(83); + END_STATE(); + case 36: + if (lookahead == 'c') ADVANCE(84); + if (lookahead == 'l') ADVANCE(85); + END_STATE(); + case 37: + if (lookahead == 'n') ADVANCE(86); + END_STATE(); + case 38: + if (lookahead == 'r') ADVANCE(87); + END_STATE(); + case 39: + if (lookahead == 't') ADVANCE(88); + END_STATE(); + case 40: + if (lookahead == 'd') ADVANCE(89); + END_STATE(); + case 41: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 42: + if (lookahead == 'p') ADVANCE(90); + END_STATE(); + case 43: + ACCEPT_TOKEN(anon_sym_in); + if (lookahead == 'l') ADVANCE(91); + if (lookahead == 't') ADVANCE(92); + END_STATE(); + case 44: + ACCEPT_TOKEN(anon_sym_is); + END_STATE(); + case 45: + if (lookahead == 't') ADVANCE(93); + END_STATE(); + case 46: + if (lookahead == 'b') ADVANCE(94); + END_STATE(); + case 47: + if (lookahead == 'x') ADVANCE(95); + END_STATE(); + case 48: + if (lookahead == 't') ADVANCE(96); + END_STATE(); + case 49: + if (lookahead == 'w') ADVANCE(97); + END_STATE(); + case 50: + if (lookahead == 'l') ADVANCE(98); + END_STATE(); + case 51: + ACCEPT_TOKEN(anon_sym_on); + END_STATE(); + case 52: + if (lookahead == 'e') ADVANCE(99); + END_STATE(); + case 53: + if (lookahead == 'r') ADVANCE(100); + END_STATE(); + case 54: + if (lookahead == 'q') ADVANCE(101); + if (lookahead == 't') ADVANCE(102); + END_STATE(); + case 55: + if (lookahead == 'a') ADVANCE(103); + if (lookahead == 't') ADVANCE(104); + END_STATE(); + case 56: + if (lookahead == 'o') ADVANCE(105); + END_STATE(); + case 57: + if (lookahead == 'a') ADVANCE(106); + END_STATE(); + case 58: + if (lookahead == 'p') ADVANCE(107); + END_STATE(); + case 59: + if (lookahead == 'i') ADVANCE(108); + END_STATE(); + case 60: + if (lookahead == 'i') ADVANCE(109); + if (lookahead == 'r') ADVANCE(110); + END_STATE(); + case 61: + if (lookahead == 'u') ADVANCE(111); + if (lookahead == 'y') ADVANCE(112); + END_STATE(); + case 62: + if (lookahead == 'p') ADVANCE(113); + END_STATE(); + case 63: + if (lookahead == 'r') ADVANCE(114); + END_STATE(); + case 64: + if (lookahead == 'i') ADVANCE(115); + END_STATE(); + case 65: + if (lookahead == 'e') ADVANCE(116); + if (lookahead == 'i') ADVANCE(117); + END_STATE(); + case 66: + if (lookahead == 't') ADVANCE(118); + END_STATE(); + case 67: + if (lookahead == 'e') ADVANCE(119); + END_STATE(); + case 68: + if (lookahead == 'c') ADVANCE(120); + END_STATE(); + case 69: + if (lookahead == 't') ADVANCE(121); + END_STATE(); + case 70: + if (lookahead == 'e') ADVANCE(122); + END_STATE(); + case 71: + if (lookahead == 'i') ADVANCE(123); + END_STATE(); + case 72: + if (lookahead == 'e') ADVANCE(124); + END_STATE(); + case 73: + if (lookahead == 'a') ADVANCE(125); + END_STATE(); + case 74: + if (lookahead == 'e') ADVANCE(126); + END_STATE(); + case 75: + if (lookahead == 'c') ADVANCE(127); + END_STATE(); + case 76: + if (lookahead == 's') ADVANCE(128); + END_STATE(); + case 77: + if (lookahead == 's') ADVANCE(129); + if (lookahead == 't') ADVANCE(130); + END_STATE(); + case 78: + if (lookahead == 'a') ADVANCE(131); + END_STATE(); + case 79: + if (lookahead == 'a') ADVANCE(132); + if (lookahead == 'e') ADVANCE(133); + END_STATE(); + case 80: + if (lookahead == 'e') ADVANCE(134); + END_STATE(); + case 81: + if (lookahead == 'm') ADVANCE(135); + END_STATE(); + case 82: + if (lookahead == 'o') ADVANCE(136); + END_STATE(); + case 83: + if (lookahead == 'e') ADVANCE(137); + END_STATE(); + case 84: + if (lookahead == 't') ADVANCE(138); + END_STATE(); + case 85: + if (lookahead == 's') ADVANCE(139); + END_STATE(); + case 86: + if (lookahead == 'a') ADVANCE(140); + END_STATE(); + case 87: + ACCEPT_TOKEN(anon_sym_for); + END_STATE(); + case 88: + ACCEPT_TOKEN(anon_sym_get); + END_STATE(); + case 89: + if (lookahead == 'e') ADVANCE(141); + END_STATE(); + case 90: + if (lookahead == 'l') ADVANCE(142); + if (lookahead == 'o') ADVANCE(143); + END_STATE(); + case 91: + if (lookahead == 'i') ADVANCE(144); + END_STATE(); + case 92: + if (lookahead == 'e') ADVANCE(145); + END_STATE(); + case 93: + if (lookahead == 'e') ADVANCE(146); + END_STATE(); + case 94: + if (lookahead == 'r') ADVANCE(147); + END_STATE(); + case 95: + if (lookahead == 'i') ADVANCE(148); + END_STATE(); + case 96: + if (lookahead == 'i') ADVANCE(149); + END_STATE(); + case 97: + ACCEPT_TOKEN(anon_sym_new); + END_STATE(); + case 98: + if (lookahead == 'l') ADVANCE(150); + END_STATE(); + case 99: + if (lookahead == 'r') ADVANCE(151); + END_STATE(); + case 100: + if (lookahead == 't') ADVANCE(152); + END_STATE(); + case 101: + if (lookahead == 'u') ADVANCE(153); + END_STATE(); + case 102: + if (lookahead == 'h') ADVANCE(154); + if (lookahead == 'u') ADVANCE(155); + END_STATE(); + case 103: + if (lookahead == 'l') ADVANCE(156); + END_STATE(); + case 104: + ACCEPT_TOKEN(anon_sym_set); + END_STATE(); + case 105: + if (lookahead == 'w') ADVANCE(157); + END_STATE(); + case 106: + if (lookahead == 't') ADVANCE(158); + END_STATE(); + case 107: + if (lookahead == 'e') ADVANCE(159); + END_STATE(); + case 108: + if (lookahead == 't') ADVANCE(160); + END_STATE(); + case 109: + if (lookahead == 's') ADVANCE(161); + END_STATE(); + case 110: + if (lookahead == 'o') ADVANCE(162); + END_STATE(); + case 111: + if (lookahead == 'e') ADVANCE(163); + END_STATE(); + case 112: + ACCEPT_TOKEN(anon_sym_try); + END_STATE(); + case 113: + if (lookahead == 'e') ADVANCE(164); + END_STATE(); + case 114: + ACCEPT_TOKEN(anon_sym_var); + END_STATE(); + case 115: + if (lookahead == 'd') ADVANCE(165); + END_STATE(); + case 116: + if (lookahead == 'n') ADVANCE(166); + END_STATE(); + case 117: + if (lookahead == 'l') ADVANCE(167); + END_STATE(); + case 118: + if (lookahead == 'h') ADVANCE(168); + END_STATE(); + case 119: + if (lookahead == 'l') ADVANCE(169); + END_STATE(); + case 120: + if (lookahead == 't') ADVANCE(170); + END_STATE(); + case 121: + if (lookahead == 'r') ADVANCE(171); + END_STATE(); + case 122: + if (lookahead == 'r') ADVANCE(172); + END_STATE(); + case 123: + if (lookahead == 't') ADVANCE(173); + END_STATE(); + case 124: + ACCEPT_TOKEN(anon_sym_base); + END_STATE(); + case 125: + if (lookahead == 'k') ADVANCE(174); + END_STATE(); + case 126: + ACCEPT_TOKEN(anon_sym_case); + END_STATE(); + case 127: + if (lookahead == 'h') ADVANCE(175); + END_STATE(); + case 128: + if (lookahead == 's') ADVANCE(176); + END_STATE(); + case 129: + if (lookahead == 't') ADVANCE(177); + END_STATE(); + case 130: + if (lookahead == 'i') ADVANCE(178); + END_STATE(); + case 131: + if (lookahead == 'r') ADVANCE(179); + END_STATE(); + case 132: + if (lookahead == 'u') ADVANCE(180); + END_STATE(); + case 133: + if (lookahead == 'r') ADVANCE(181); + END_STATE(); + case 134: + ACCEPT_TOKEN(anon_sym_else); + END_STATE(); + case 135: + ACCEPT_TOKEN(anon_sym_enum); + END_STATE(); + case 136: + if (lookahead == 'r') ADVANCE(182); + END_STATE(); + case 137: + if (lookahead == 'n') ADVANCE(183); + if (lookahead == 'r') ADVANCE(184); + END_STATE(); + case 138: + if (lookahead == 'o') ADVANCE(185); + END_STATE(); + case 139: + if (lookahead == 'e') ADVANCE(186); + END_STATE(); + case 140: + if (lookahead == 'l') ADVANCE(187); + END_STATE(); + case 141: + ACCEPT_TOKEN(anon_sym_hide); + END_STATE(); + case 142: + if (lookahead == 'e') ADVANCE(188); + END_STATE(); + case 143: + if (lookahead == 'r') ADVANCE(189); + END_STATE(); + case 144: + if (lookahead == 'n') ADVANCE(190); + END_STATE(); + case 145: + if (lookahead == 'r') ADVANCE(191); + END_STATE(); + case 146: + ACCEPT_TOKEN(anon_sym_late); + END_STATE(); + case 147: + if (lookahead == 'a') ADVANCE(192); + END_STATE(); + case 148: + if (lookahead == 'n') ADVANCE(193); + END_STATE(); + case 149: + if (lookahead == 'v') ADVANCE(194); + END_STATE(); + case 150: + ACCEPT_TOKEN(anon_sym_null); + END_STATE(); + case 151: + if (lookahead == 'a') ADVANCE(195); + END_STATE(); + case 152: + ACCEPT_TOKEN(anon_sym_part); + END_STATE(); + case 153: + if (lookahead == 'i') ADVANCE(196); + END_STATE(); + case 154: + if (lookahead == 'r') ADVANCE(197); + END_STATE(); + case 155: + if (lookahead == 'r') ADVANCE(198); + END_STATE(); + case 156: + if (lookahead == 'e') ADVANCE(199); + END_STATE(); + case 157: + ACCEPT_TOKEN(anon_sym_show); + END_STATE(); + case 158: + if (lookahead == 'i') ADVANCE(200); + END_STATE(); + case 159: + if (lookahead == 'r') ADVANCE(201); + END_STATE(); + case 160: + if (lookahead == 'c') ADVANCE(202); + END_STATE(); + case 161: + ACCEPT_TOKEN(anon_sym_this); + END_STATE(); + case 162: + if (lookahead == 'w') ADVANCE(203); + END_STATE(); + case 163: + ACCEPT_TOKEN(anon_sym_true); + END_STATE(); + case 164: + ACCEPT_TOKEN(anon_sym_type); + if (lookahead == 'd') ADVANCE(204); + END_STATE(); + case 165: + ACCEPT_TOKEN(sym_void_type); + END_STATE(); + case 166: + ACCEPT_TOKEN(anon_sym_when); + END_STATE(); + case 167: + if (lookahead == 'e') ADVANCE(205); + END_STATE(); + case 168: + ACCEPT_TOKEN(anon_sym_with); + END_STATE(); + case 169: + if (lookahead == 'd') ADVANCE(206); + END_STATE(); + case 170: + if (lookahead == 'i') ADVANCE(207); + END_STATE(); + case 171: + if (lookahead == 'a') ADVANCE(208); + END_STATE(); + case 172: + if (lookahead == 't') ADVANCE(209); + END_STATE(); + case 173: + ACCEPT_TOKEN(anon_sym_await); + END_STATE(); + case 174: + ACCEPT_TOKEN(sym_break_builtin); + END_STATE(); + case 175: + ACCEPT_TOKEN(anon_sym_catch); + END_STATE(); + case 176: + ACCEPT_TOKEN(anon_sym_class); + END_STATE(); + case 177: + ACCEPT_TOKEN(sym_const_builtin); + END_STATE(); + case 178: + if (lookahead == 'n') ADVANCE(210); + END_STATE(); + case 179: + if (lookahead == 'i') ADVANCE(211); + END_STATE(); + case 180: + if (lookahead == 'l') ADVANCE(212); + END_STATE(); + case 181: + if (lookahead == 'r') ADVANCE(213); + END_STATE(); + case 182: + if (lookahead == 't') ADVANCE(214); + END_STATE(); + case 183: + if (lookahead == 'd') ADVANCE(215); + if (lookahead == 's') ADVANCE(216); + END_STATE(); + case 184: + if (lookahead == 'n') ADVANCE(217); + END_STATE(); + case 185: + if (lookahead == 'r') ADVANCE(218); + END_STATE(); + case 186: + ACCEPT_TOKEN(anon_sym_false); + END_STATE(); + case 187: + ACCEPT_TOKEN(anon_sym_final); + if (lookahead == 'l') ADVANCE(219); + END_STATE(); + case 188: + if (lookahead == 'm') ADVANCE(220); + END_STATE(); + case 189: + if (lookahead == 't') ADVANCE(221); + END_STATE(); + case 190: + if (lookahead == 'e') ADVANCE(222); + END_STATE(); + case 191: + if (lookahead == 'f') ADVANCE(223); + END_STATE(); + case 192: + if (lookahead == 'r') ADVANCE(224); + END_STATE(); + case 193: + ACCEPT_TOKEN(anon_sym_mixin); + END_STATE(); + case 194: + if (lookahead == 'e') ADVANCE(225); + END_STATE(); + case 195: + if (lookahead == 't') ADVANCE(226); + END_STATE(); + case 196: + if (lookahead == 'r') ADVANCE(227); + END_STATE(); + case 197: + if (lookahead == 'o') ADVANCE(228); + END_STATE(); + case 198: + if (lookahead == 'n') ADVANCE(229); + END_STATE(); + case 199: + if (lookahead == 'd') ADVANCE(230); + END_STATE(); + case 200: + if (lookahead == 'c') ADVANCE(231); + END_STATE(); + case 201: + ACCEPT_TOKEN(anon_sym_super); + END_STATE(); + case 202: + if (lookahead == 'h') ADVANCE(232); + END_STATE(); + case 203: + ACCEPT_TOKEN(anon_sym_throw); + END_STATE(); + case 204: + if (lookahead == 'e') ADVANCE(233); + END_STATE(); + case 205: + ACCEPT_TOKEN(anon_sym_while); + END_STATE(); + case 206: + ACCEPT_TOKEN(anon_sym_yield); + END_STATE(); + case 207: + if (lookahead == 'o') ADVANCE(234); + END_STATE(); + case 208: + if (lookahead == 'c') ADVANCE(235); + END_STATE(); + case 209: + ACCEPT_TOKEN(sym_assert_builtin); + END_STATE(); + case 210: + if (lookahead == 'u') ADVANCE(236); + END_STATE(); + case 211: + if (lookahead == 'a') ADVANCE(237); + END_STATE(); + case 212: + if (lookahead == 't') ADVANCE(238); + END_STATE(); + case 213: + if (lookahead == 'e') ADVANCE(239); + END_STATE(); + case 214: + ACCEPT_TOKEN(anon_sym_export); + END_STATE(); + case 215: + if (lookahead == 's') ADVANCE(240); + END_STATE(); + case 216: + if (lookahead == 'i') ADVANCE(241); + END_STATE(); + case 217: + if (lookahead == 'a') ADVANCE(242); + END_STATE(); + case 218: + if (lookahead == 'y') ADVANCE(243); + END_STATE(); + case 219: + if (lookahead == 'y') ADVANCE(244); + END_STATE(); + case 220: + if (lookahead == 'e') ADVANCE(245); + END_STATE(); + case 221: + ACCEPT_TOKEN(anon_sym_import); + END_STATE(); + case 222: + ACCEPT_TOKEN(anon_sym_inline); + END_STATE(); + case 223: + if (lookahead == 'a') ADVANCE(246); + END_STATE(); + case 224: + if (lookahead == 'y') ADVANCE(247); + END_STATE(); + case 225: + ACCEPT_TOKEN(anon_sym_native); + END_STATE(); + case 226: + if (lookahead == 'o') ADVANCE(248); + END_STATE(); + case 227: + if (lookahead == 'e') ADVANCE(249); + END_STATE(); + case 228: + if (lookahead == 'w') ADVANCE(250); + END_STATE(); + case 229: + ACCEPT_TOKEN(anon_sym_return); + END_STATE(); + case 230: + ACCEPT_TOKEN(anon_sym_sealed); + END_STATE(); + case 231: + ACCEPT_TOKEN(anon_sym_static); + END_STATE(); + case 232: + ACCEPT_TOKEN(anon_sym_switch); + END_STATE(); + case 233: + if (lookahead == 'f') ADVANCE(251); + END_STATE(); + case 234: + if (lookahead == 'n') ADVANCE(252); + END_STATE(); + case 235: + if (lookahead == 't') ADVANCE(253); + END_STATE(); + case 236: + if (lookahead == 'e') ADVANCE(254); + END_STATE(); + case 237: + if (lookahead == 'n') ADVANCE(255); + END_STATE(); + case 238: + ACCEPT_TOKEN(anon_sym_default); + END_STATE(); + case 239: + if (lookahead == 'd') ADVANCE(256); + END_STATE(); + case 240: + ACCEPT_TOKEN(anon_sym_extends); + END_STATE(); + case 241: + if (lookahead == 'o') ADVANCE(257); + END_STATE(); + case 242: + if (lookahead == 'l') ADVANCE(258); + END_STATE(); + case 243: + ACCEPT_TOKEN(anon_sym_factory); + END_STATE(); + case 244: + ACCEPT_TOKEN(anon_sym_finally); + END_STATE(); + case 245: + if (lookahead == 'n') ADVANCE(259); + END_STATE(); + case 246: + if (lookahead == 'c') ADVANCE(260); + END_STATE(); + case 247: + ACCEPT_TOKEN(anon_sym_library); + END_STATE(); + case 248: + if (lookahead == 'r') ADVANCE(261); + END_STATE(); + case 249: + if (lookahead == 'd') ADVANCE(262); + END_STATE(); + case 250: + ACCEPT_TOKEN(sym_rethrow_builtin); + END_STATE(); + case 251: + ACCEPT_TOKEN(anon_sym_typedef); + END_STATE(); + case 252: + ACCEPT_TOKEN(anon_sym_Function); + END_STATE(); + case 253: + ACCEPT_TOKEN(anon_sym_abstract); + END_STATE(); + case 254: + ACCEPT_TOKEN(anon_sym_continue); + END_STATE(); + case 255: + if (lookahead == 't') ADVANCE(263); + END_STATE(); + case 256: + ACCEPT_TOKEN(anon_sym_deferred); + END_STATE(); + case 257: + if (lookahead == 'n') ADVANCE(264); + END_STATE(); + case 258: + ACCEPT_TOKEN(anon_sym_external); + END_STATE(); + case 259: + if (lookahead == 't') ADVANCE(265); + END_STATE(); + case 260: + if (lookahead == 'e') ADVANCE(266); + END_STATE(); + case 261: + ACCEPT_TOKEN(anon_sym_operator); + END_STATE(); + case 262: + ACCEPT_TOKEN(anon_sym_required); + END_STATE(); + case 263: + ACCEPT_TOKEN(anon_sym_covariant); + END_STATE(); + case 264: + ACCEPT_TOKEN(anon_sym_extension); + END_STATE(); + case 265: + if (lookahead == 's') ADVANCE(267); + END_STATE(); + case 266: + ACCEPT_TOKEN(anon_sym_interface); + END_STATE(); + case 267: + ACCEPT_TOKEN(anon_sym_implements); + END_STATE(); + default: + return false; + } +} + +static const TSLexerMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 100, .external_lex_state = 2}, + [2] = {.lex_state = 101, .external_lex_state = 2}, + [3] = {.lex_state = 101, .external_lex_state = 2}, + [4] = {.lex_state = 101, .external_lex_state = 2}, + [5] = {.lex_state = 101, .external_lex_state = 2}, + [6] = {.lex_state = 101, .external_lex_state = 2}, + [7] = {.lex_state = 101, .external_lex_state = 2}, + [8] = {.lex_state = 101, .external_lex_state = 2}, + [9] = {.lex_state = 101, .external_lex_state = 2}, + [10] = {.lex_state = 101, .external_lex_state = 2}, + [11] = {.lex_state = 101, .external_lex_state = 2}, + [12] = {.lex_state = 101, .external_lex_state = 2}, + [13] = {.lex_state = 101, .external_lex_state = 2}, + [14] = {.lex_state = 4, .external_lex_state = 2}, + [15] = {.lex_state = 4, .external_lex_state = 2}, + [16] = {.lex_state = 101, .external_lex_state = 2}, + [17] = {.lex_state = 101, .external_lex_state = 2}, + [18] = {.lex_state = 101, .external_lex_state = 2}, + [19] = {.lex_state = 101, .external_lex_state = 2}, + [20] = {.lex_state = 101, .external_lex_state = 2}, + [21] = {.lex_state = 101, .external_lex_state = 2}, + [22] = {.lex_state = 101, .external_lex_state = 2}, + [23] = {.lex_state = 101, .external_lex_state = 2}, + [24] = {.lex_state = 101, .external_lex_state = 2}, + [25] = {.lex_state = 101, .external_lex_state = 2}, + [26] = {.lex_state = 101, .external_lex_state = 2}, + [27] = {.lex_state = 101, .external_lex_state = 2}, + [28] = {.lex_state = 101, .external_lex_state = 2}, + [29] = {.lex_state = 101, .external_lex_state = 2}, + [30] = {.lex_state = 4, .external_lex_state = 2}, + [31] = {.lex_state = 101, .external_lex_state = 2}, + [32] = {.lex_state = 101, .external_lex_state = 2}, + [33] = {.lex_state = 4, .external_lex_state = 2}, + [34] = {.lex_state = 101, .external_lex_state = 2}, + [35] = {.lex_state = 101, .external_lex_state = 2}, + [36] = {.lex_state = 101, .external_lex_state = 2}, + [37] = {.lex_state = 101, .external_lex_state = 2}, + [38] = {.lex_state = 101, .external_lex_state = 2}, + [39] = {.lex_state = 101, .external_lex_state = 2}, + [40] = {.lex_state = 101, .external_lex_state = 2}, + [41] = {.lex_state = 101, .external_lex_state = 2}, + [42] = {.lex_state = 101, .external_lex_state = 2}, + [43] = {.lex_state = 101, .external_lex_state = 2}, + [44] = {.lex_state = 101, .external_lex_state = 2}, + [45] = {.lex_state = 101, .external_lex_state = 2}, + [46] = {.lex_state = 101, .external_lex_state = 2}, + [47] = {.lex_state = 4, .external_lex_state = 2}, + [48] = {.lex_state = 101, .external_lex_state = 2}, + [49] = {.lex_state = 101, .external_lex_state = 2}, + [50] = {.lex_state = 101, .external_lex_state = 2}, + [51] = {.lex_state = 4, .external_lex_state = 2}, + [52] = {.lex_state = 4, .external_lex_state = 2}, + [53] = {.lex_state = 4, .external_lex_state = 2}, + [54] = {.lex_state = 4, .external_lex_state = 2}, + [55] = {.lex_state = 4, .external_lex_state = 2}, + [56] = {.lex_state = 4, .external_lex_state = 2}, + [57] = {.lex_state = 101, .external_lex_state = 2}, + [58] = {.lex_state = 101, .external_lex_state = 2}, + [59] = {.lex_state = 101, .external_lex_state = 2}, + [60] = {.lex_state = 101, .external_lex_state = 2}, + [61] = {.lex_state = 4, .external_lex_state = 2}, + [62] = {.lex_state = 4, .external_lex_state = 2}, + [63] = {.lex_state = 101, .external_lex_state = 2}, + [64] = {.lex_state = 101, .external_lex_state = 2}, + [65] = {.lex_state = 101, .external_lex_state = 2}, + [66] = {.lex_state = 101, .external_lex_state = 2}, + [67] = {.lex_state = 101, .external_lex_state = 2}, + [68] = {.lex_state = 101, .external_lex_state = 2}, + [69] = {.lex_state = 101, .external_lex_state = 2}, + [70] = {.lex_state = 101, .external_lex_state = 2}, + [71] = {.lex_state = 101, .external_lex_state = 2}, + [72] = {.lex_state = 101, .external_lex_state = 2}, + [73] = {.lex_state = 101, .external_lex_state = 2}, + [74] = {.lex_state = 101, .external_lex_state = 2}, + [75] = {.lex_state = 101, .external_lex_state = 2}, + [76] = {.lex_state = 101, .external_lex_state = 2}, + [77] = {.lex_state = 101, .external_lex_state = 2}, + [78] = {.lex_state = 101, .external_lex_state = 2}, + [79] = {.lex_state = 101, .external_lex_state = 2}, + [80] = {.lex_state = 101, .external_lex_state = 2}, + [81] = {.lex_state = 101, .external_lex_state = 2}, + [82] = {.lex_state = 101, .external_lex_state = 2}, + [83] = {.lex_state = 101, .external_lex_state = 2}, + [84] = {.lex_state = 101, .external_lex_state = 2}, + [85] = {.lex_state = 101, .external_lex_state = 2}, + [86] = {.lex_state = 101, .external_lex_state = 2}, + [87] = {.lex_state = 101, .external_lex_state = 2}, + [88] = {.lex_state = 101, .external_lex_state = 2}, + [89] = {.lex_state = 101, .external_lex_state = 2}, + [90] = {.lex_state = 101, .external_lex_state = 2}, + [91] = {.lex_state = 101, .external_lex_state = 2}, + [92] = {.lex_state = 101, .external_lex_state = 2}, + [93] = {.lex_state = 101, .external_lex_state = 2}, + [94] = {.lex_state = 101, .external_lex_state = 2}, + [95] = {.lex_state = 101, .external_lex_state = 2}, + [96] = {.lex_state = 101, .external_lex_state = 2}, + [97] = {.lex_state = 101, .external_lex_state = 2}, + [98] = {.lex_state = 101, .external_lex_state = 2}, + [99] = {.lex_state = 101, .external_lex_state = 2}, + [100] = {.lex_state = 101, .external_lex_state = 2}, + [101] = {.lex_state = 101, .external_lex_state = 2}, + [102] = {.lex_state = 101, .external_lex_state = 2}, + [103] = {.lex_state = 101, .external_lex_state = 2}, + [104] = {.lex_state = 101, .external_lex_state = 2}, + [105] = {.lex_state = 101, .external_lex_state = 2}, + [106] = {.lex_state = 101, .external_lex_state = 2}, + [107] = {.lex_state = 101, .external_lex_state = 2}, + [108] = {.lex_state = 101, .external_lex_state = 2}, + [109] = {.lex_state = 101, .external_lex_state = 2}, + [110] = {.lex_state = 101, .external_lex_state = 2}, + [111] = {.lex_state = 101, .external_lex_state = 2}, + [112] = {.lex_state = 101, .external_lex_state = 2}, + [113] = {.lex_state = 101, .external_lex_state = 2}, + [114] = {.lex_state = 101, .external_lex_state = 2}, + [115] = {.lex_state = 101, .external_lex_state = 2}, + [116] = {.lex_state = 101, .external_lex_state = 2}, + [117] = {.lex_state = 101, .external_lex_state = 2}, + [118] = {.lex_state = 101, .external_lex_state = 2}, + [119] = {.lex_state = 101, .external_lex_state = 2}, + [120] = {.lex_state = 101, .external_lex_state = 2}, + [121] = {.lex_state = 101, .external_lex_state = 2}, + [122] = {.lex_state = 101, .external_lex_state = 2}, + [123] = {.lex_state = 101, .external_lex_state = 2}, + [124] = {.lex_state = 101, .external_lex_state = 2}, + [125] = {.lex_state = 101, .external_lex_state = 2}, + [126] = {.lex_state = 101, .external_lex_state = 2}, + [127] = {.lex_state = 101, .external_lex_state = 2}, + [128] = {.lex_state = 101, .external_lex_state = 2}, + [129] = {.lex_state = 101, .external_lex_state = 2}, + [130] = {.lex_state = 101, .external_lex_state = 2}, + [131] = {.lex_state = 101, .external_lex_state = 2}, + [132] = {.lex_state = 101, .external_lex_state = 2}, + [133] = {.lex_state = 101, .external_lex_state = 2}, + [134] = {.lex_state = 101, .external_lex_state = 2}, + [135] = {.lex_state = 101, .external_lex_state = 2}, + [136] = {.lex_state = 101, .external_lex_state = 2}, + [137] = {.lex_state = 101, .external_lex_state = 2}, + [138] = {.lex_state = 101, .external_lex_state = 2}, + [139] = {.lex_state = 101, .external_lex_state = 2}, + [140] = {.lex_state = 101, .external_lex_state = 2}, + [141] = {.lex_state = 101, .external_lex_state = 2}, + [142] = {.lex_state = 101, .external_lex_state = 2}, + [143] = {.lex_state = 101, .external_lex_state = 2}, + [144] = {.lex_state = 101, .external_lex_state = 2}, + [145] = {.lex_state = 101, .external_lex_state = 2}, + [146] = {.lex_state = 101, .external_lex_state = 2}, + [147] = {.lex_state = 101, .external_lex_state = 2}, + [148] = {.lex_state = 101, .external_lex_state = 2}, + [149] = {.lex_state = 101, .external_lex_state = 2}, + [150] = {.lex_state = 101, .external_lex_state = 2}, + [151] = {.lex_state = 101, .external_lex_state = 2}, + [152] = {.lex_state = 101, .external_lex_state = 2}, + [153] = {.lex_state = 101, .external_lex_state = 2}, + [154] = {.lex_state = 101, .external_lex_state = 2}, + [155] = {.lex_state = 101, .external_lex_state = 2}, + [156] = {.lex_state = 101, .external_lex_state = 2}, + [157] = {.lex_state = 101, .external_lex_state = 2}, + [158] = {.lex_state = 101, .external_lex_state = 2}, + [159] = {.lex_state = 101, .external_lex_state = 2}, + [160] = {.lex_state = 101, .external_lex_state = 2}, + [161] = {.lex_state = 101, .external_lex_state = 2}, + [162] = {.lex_state = 101, .external_lex_state = 2}, + [163] = {.lex_state = 101, .external_lex_state = 2}, + [164] = {.lex_state = 101, .external_lex_state = 2}, + [165] = {.lex_state = 101, .external_lex_state = 2}, + [166] = {.lex_state = 101, .external_lex_state = 2}, + [167] = {.lex_state = 101, .external_lex_state = 2}, + [168] = {.lex_state = 101, .external_lex_state = 2}, + [169] = {.lex_state = 101, .external_lex_state = 2}, + [170] = {.lex_state = 101, .external_lex_state = 2}, + [171] = {.lex_state = 101, .external_lex_state = 2}, + [172] = {.lex_state = 101, .external_lex_state = 2}, + [173] = {.lex_state = 101, .external_lex_state = 2}, + [174] = {.lex_state = 101, .external_lex_state = 2}, + [175] = {.lex_state = 101, .external_lex_state = 2}, + [176] = {.lex_state = 101, .external_lex_state = 2}, + [177] = {.lex_state = 101, .external_lex_state = 2}, + [178] = {.lex_state = 101, .external_lex_state = 2}, + [179] = {.lex_state = 101, .external_lex_state = 2}, + [180] = {.lex_state = 101, .external_lex_state = 2}, + [181] = {.lex_state = 101, .external_lex_state = 2}, + [182] = {.lex_state = 101, .external_lex_state = 2}, + [183] = {.lex_state = 101, .external_lex_state = 2}, + [184] = {.lex_state = 101, .external_lex_state = 2}, + [185] = {.lex_state = 101, .external_lex_state = 2}, + [186] = {.lex_state = 101, .external_lex_state = 2}, + [187] = {.lex_state = 101, .external_lex_state = 2}, + [188] = {.lex_state = 101, .external_lex_state = 2}, + [189] = {.lex_state = 101, .external_lex_state = 2}, + [190] = {.lex_state = 101, .external_lex_state = 2}, + [191] = {.lex_state = 101, .external_lex_state = 2}, + [192] = {.lex_state = 101, .external_lex_state = 2}, + [193] = {.lex_state = 101, .external_lex_state = 2}, + [194] = {.lex_state = 101, .external_lex_state = 2}, + [195] = {.lex_state = 101, .external_lex_state = 2}, + [196] = {.lex_state = 101, .external_lex_state = 2}, + [197] = {.lex_state = 101, .external_lex_state = 2}, + [198] = {.lex_state = 101, .external_lex_state = 2}, + [199] = {.lex_state = 101, .external_lex_state = 2}, + [200] = {.lex_state = 101, .external_lex_state = 2}, + [201] = {.lex_state = 101, .external_lex_state = 2}, + [202] = {.lex_state = 101, .external_lex_state = 2}, + [203] = {.lex_state = 101, .external_lex_state = 2}, + [204] = {.lex_state = 101, .external_lex_state = 2}, + [205] = {.lex_state = 101, .external_lex_state = 2}, + [206] = {.lex_state = 101, .external_lex_state = 2}, + [207] = {.lex_state = 101, .external_lex_state = 2}, + [208] = {.lex_state = 101, .external_lex_state = 2}, + [209] = {.lex_state = 101, .external_lex_state = 2}, + [210] = {.lex_state = 101, .external_lex_state = 2}, + [211] = {.lex_state = 101, .external_lex_state = 2}, + [212] = {.lex_state = 101, .external_lex_state = 2}, + [213] = {.lex_state = 101, .external_lex_state = 2}, + [214] = {.lex_state = 101, .external_lex_state = 2}, + [215] = {.lex_state = 101, .external_lex_state = 2}, + [216] = {.lex_state = 101, .external_lex_state = 2}, + [217] = {.lex_state = 101, .external_lex_state = 2}, + [218] = {.lex_state = 101, .external_lex_state = 2}, + [219] = {.lex_state = 101, .external_lex_state = 2}, + [220] = {.lex_state = 101, .external_lex_state = 2}, + [221] = {.lex_state = 101, .external_lex_state = 2}, + [222] = {.lex_state = 101, .external_lex_state = 2}, + [223] = {.lex_state = 101, .external_lex_state = 2}, + [224] = {.lex_state = 101, .external_lex_state = 2}, + [225] = {.lex_state = 101, .external_lex_state = 2}, + [226] = {.lex_state = 101, .external_lex_state = 2}, + [227] = {.lex_state = 101, .external_lex_state = 2}, + [228] = {.lex_state = 101, .external_lex_state = 2}, + [229] = {.lex_state = 101, .external_lex_state = 2}, + [230] = {.lex_state = 101, .external_lex_state = 2}, + [231] = {.lex_state = 101, .external_lex_state = 2}, + [232] = {.lex_state = 101, .external_lex_state = 2}, + [233] = {.lex_state = 101, .external_lex_state = 2}, + [234] = {.lex_state = 101, .external_lex_state = 2}, + [235] = {.lex_state = 101, .external_lex_state = 2}, + [236] = {.lex_state = 101, .external_lex_state = 2}, + [237] = {.lex_state = 101, .external_lex_state = 2}, + [238] = {.lex_state = 101, .external_lex_state = 2}, + [239] = {.lex_state = 101, .external_lex_state = 2}, + [240] = {.lex_state = 101, .external_lex_state = 2}, + [241] = {.lex_state = 101, .external_lex_state = 2}, + [242] = {.lex_state = 101, .external_lex_state = 2}, + [243] = {.lex_state = 101, .external_lex_state = 2}, + [244] = {.lex_state = 101, .external_lex_state = 2}, + [245] = {.lex_state = 101, .external_lex_state = 2}, + [246] = {.lex_state = 101, .external_lex_state = 2}, + [247] = {.lex_state = 101, .external_lex_state = 2}, + [248] = {.lex_state = 101, .external_lex_state = 2}, + [249] = {.lex_state = 101, .external_lex_state = 2}, + [250] = {.lex_state = 101, .external_lex_state = 2}, + [251] = {.lex_state = 101, .external_lex_state = 2}, + [252] = {.lex_state = 101, .external_lex_state = 2}, + [253] = {.lex_state = 101, .external_lex_state = 2}, + [254] = {.lex_state = 101, .external_lex_state = 2}, + [255] = {.lex_state = 101, .external_lex_state = 2}, + [256] = {.lex_state = 101, .external_lex_state = 2}, + [257] = {.lex_state = 101, .external_lex_state = 2}, + [258] = {.lex_state = 101, .external_lex_state = 2}, + [259] = {.lex_state = 101, .external_lex_state = 2}, + [260] = {.lex_state = 101, .external_lex_state = 2}, + [261] = {.lex_state = 101, .external_lex_state = 2}, + [262] = {.lex_state = 101, .external_lex_state = 2}, + [263] = {.lex_state = 101, .external_lex_state = 2}, + [264] = {.lex_state = 101, .external_lex_state = 2}, + [265] = {.lex_state = 101, .external_lex_state = 2}, + [266] = {.lex_state = 101, .external_lex_state = 2}, + [267] = {.lex_state = 101, .external_lex_state = 2}, + [268] = {.lex_state = 101, .external_lex_state = 2}, + [269] = {.lex_state = 101, .external_lex_state = 2}, + [270] = {.lex_state = 101, .external_lex_state = 2}, + [271] = {.lex_state = 101, .external_lex_state = 2}, + [272] = {.lex_state = 101, .external_lex_state = 2}, + [273] = {.lex_state = 101, .external_lex_state = 2}, + [274] = {.lex_state = 101, .external_lex_state = 2}, + [275] = {.lex_state = 101, .external_lex_state = 2}, + [276] = {.lex_state = 101, .external_lex_state = 2}, + [277] = {.lex_state = 101, .external_lex_state = 2}, + [278] = {.lex_state = 101, .external_lex_state = 2}, + [279] = {.lex_state = 101, .external_lex_state = 2}, + [280] = {.lex_state = 101, .external_lex_state = 2}, + [281] = {.lex_state = 101, .external_lex_state = 2}, + [282] = {.lex_state = 101, .external_lex_state = 2}, + [283] = {.lex_state = 101, .external_lex_state = 2}, + [284] = {.lex_state = 101, .external_lex_state = 2}, + [285] = {.lex_state = 101, .external_lex_state = 2}, + [286] = {.lex_state = 101, .external_lex_state = 2}, + [287] = {.lex_state = 101, .external_lex_state = 2}, + [288] = {.lex_state = 101, .external_lex_state = 2}, + [289] = {.lex_state = 101, .external_lex_state = 2}, + [290] = {.lex_state = 101, .external_lex_state = 2}, + [291] = {.lex_state = 101, .external_lex_state = 2}, + [292] = {.lex_state = 101, .external_lex_state = 2}, + [293] = {.lex_state = 101, .external_lex_state = 2}, + [294] = {.lex_state = 101, .external_lex_state = 2}, + [295] = {.lex_state = 101, .external_lex_state = 2}, + [296] = {.lex_state = 101, .external_lex_state = 2}, + [297] = {.lex_state = 101, .external_lex_state = 2}, + [298] = {.lex_state = 101, .external_lex_state = 2}, + [299] = {.lex_state = 101, .external_lex_state = 2}, + [300] = {.lex_state = 101, .external_lex_state = 2}, + [301] = {.lex_state = 101, .external_lex_state = 2}, + [302] = {.lex_state = 101, .external_lex_state = 2}, + [303] = {.lex_state = 101, .external_lex_state = 2}, + [304] = {.lex_state = 101, .external_lex_state = 2}, + [305] = {.lex_state = 101, .external_lex_state = 2}, + [306] = {.lex_state = 101, .external_lex_state = 2}, + [307] = {.lex_state = 101, .external_lex_state = 2}, + [308] = {.lex_state = 101, .external_lex_state = 2}, + [309] = {.lex_state = 101, .external_lex_state = 2}, + [310] = {.lex_state = 101, .external_lex_state = 2}, + [311] = {.lex_state = 101, .external_lex_state = 2}, + [312] = {.lex_state = 101, .external_lex_state = 2}, + [313] = {.lex_state = 101, .external_lex_state = 2}, + [314] = {.lex_state = 101, .external_lex_state = 2}, + [315] = {.lex_state = 101, .external_lex_state = 2}, + [316] = {.lex_state = 101, .external_lex_state = 2}, + [317] = {.lex_state = 101, .external_lex_state = 2}, + [318] = {.lex_state = 101, .external_lex_state = 2}, + [319] = {.lex_state = 101, .external_lex_state = 2}, + [320] = {.lex_state = 101, .external_lex_state = 2}, + [321] = {.lex_state = 101, .external_lex_state = 2}, + [322] = {.lex_state = 101, .external_lex_state = 2}, + [323] = {.lex_state = 101, .external_lex_state = 2}, + [324] = {.lex_state = 101, .external_lex_state = 2}, + [325] = {.lex_state = 101, .external_lex_state = 2}, + [326] = {.lex_state = 101, .external_lex_state = 2}, + [327] = {.lex_state = 101, .external_lex_state = 2}, + [328] = {.lex_state = 101, .external_lex_state = 2}, + [329] = {.lex_state = 101, .external_lex_state = 2}, + [330] = {.lex_state = 101, .external_lex_state = 2}, + [331] = {.lex_state = 101, .external_lex_state = 2}, + [332] = {.lex_state = 101, .external_lex_state = 2}, + [333] = {.lex_state = 101, .external_lex_state = 2}, + [334] = {.lex_state = 101, .external_lex_state = 2}, + [335] = {.lex_state = 101, .external_lex_state = 2}, + [336] = {.lex_state = 101, .external_lex_state = 2}, + [337] = {.lex_state = 101, .external_lex_state = 2}, + [338] = {.lex_state = 101, .external_lex_state = 2}, + [339] = {.lex_state = 101, .external_lex_state = 2}, + [340] = {.lex_state = 101, .external_lex_state = 2}, + [341] = {.lex_state = 101, .external_lex_state = 2}, + [342] = {.lex_state = 101, .external_lex_state = 2}, + [343] = {.lex_state = 101, .external_lex_state = 2}, + [344] = {.lex_state = 101, .external_lex_state = 2}, + [345] = {.lex_state = 101, .external_lex_state = 2}, + [346] = {.lex_state = 101, .external_lex_state = 2}, + [347] = {.lex_state = 101, .external_lex_state = 2}, + [348] = {.lex_state = 101, .external_lex_state = 2}, + [349] = {.lex_state = 101, .external_lex_state = 2}, + [350] = {.lex_state = 101, .external_lex_state = 2}, + [351] = {.lex_state = 101, .external_lex_state = 2}, + [352] = {.lex_state = 101, .external_lex_state = 2}, + [353] = {.lex_state = 101, .external_lex_state = 2}, + [354] = {.lex_state = 101, .external_lex_state = 2}, + [355] = {.lex_state = 101, .external_lex_state = 2}, + [356] = {.lex_state = 101, .external_lex_state = 2}, + [357] = {.lex_state = 101, .external_lex_state = 2}, + [358] = {.lex_state = 101, .external_lex_state = 2}, + [359] = {.lex_state = 101, .external_lex_state = 2}, + [360] = {.lex_state = 101, .external_lex_state = 2}, + [361] = {.lex_state = 101, .external_lex_state = 2}, + [362] = {.lex_state = 101, .external_lex_state = 2}, + [363] = {.lex_state = 101, .external_lex_state = 2}, + [364] = {.lex_state = 101, .external_lex_state = 2}, + [365] = {.lex_state = 101, .external_lex_state = 2}, + [366] = {.lex_state = 101, .external_lex_state = 2}, + [367] = {.lex_state = 101, .external_lex_state = 2}, + [368] = {.lex_state = 101, .external_lex_state = 2}, + [369] = {.lex_state = 101, .external_lex_state = 2}, + [370] = {.lex_state = 101, .external_lex_state = 2}, + [371] = {.lex_state = 101, .external_lex_state = 2}, + [372] = {.lex_state = 101, .external_lex_state = 2}, + [373] = {.lex_state = 101, .external_lex_state = 2}, + [374] = {.lex_state = 4, .external_lex_state = 2}, + [375] = {.lex_state = 25, .external_lex_state = 2}, + [376] = {.lex_state = 25, .external_lex_state = 2}, + [377] = {.lex_state = 101, .external_lex_state = 2}, + [378] = {.lex_state = 101, .external_lex_state = 2}, + [379] = {.lex_state = 101, .external_lex_state = 2}, + [380] = {.lex_state = 101, .external_lex_state = 2}, + [381] = {.lex_state = 101, .external_lex_state = 2}, + [382] = {.lex_state = 101, .external_lex_state = 2}, + [383] = {.lex_state = 25, .external_lex_state = 2}, + [384] = {.lex_state = 101, .external_lex_state = 2}, + [385] = {.lex_state = 25, .external_lex_state = 2}, + [386] = {.lex_state = 101, .external_lex_state = 2}, + [387] = {.lex_state = 25, .external_lex_state = 2}, + [388] = {.lex_state = 3, .external_lex_state = 2}, + [389] = {.lex_state = 101, .external_lex_state = 2}, + [390] = {.lex_state = 101, .external_lex_state = 2}, + [391] = {.lex_state = 101, .external_lex_state = 2}, + [392] = {.lex_state = 25, .external_lex_state = 2}, + [393] = {.lex_state = 101, .external_lex_state = 2}, + [394] = {.lex_state = 25, .external_lex_state = 2}, + [395] = {.lex_state = 101, .external_lex_state = 2}, + [396] = {.lex_state = 101, .external_lex_state = 2}, + [397] = {.lex_state = 101, .external_lex_state = 2}, + [398] = {.lex_state = 3, .external_lex_state = 2}, + [399] = {.lex_state = 101, .external_lex_state = 2}, + [400] = {.lex_state = 101, .external_lex_state = 2}, + [401] = {.lex_state = 101, .external_lex_state = 2}, + [402] = {.lex_state = 101, .external_lex_state = 2}, + [403] = {.lex_state = 25, .external_lex_state = 2}, + [404] = {.lex_state = 25, .external_lex_state = 2}, + [405] = {.lex_state = 25, .external_lex_state = 2}, + [406] = {.lex_state = 25, .external_lex_state = 2}, + [407] = {.lex_state = 25, .external_lex_state = 2}, + [408] = {.lex_state = 25, .external_lex_state = 2}, + [409] = {.lex_state = 25, .external_lex_state = 2}, + [410] = {.lex_state = 25, .external_lex_state = 2}, + [411] = {.lex_state = 25, .external_lex_state = 2}, + [412] = {.lex_state = 25, .external_lex_state = 2}, + [413] = {.lex_state = 25, .external_lex_state = 2}, + [414] = {.lex_state = 25, .external_lex_state = 2}, + [415] = {.lex_state = 25, .external_lex_state = 2}, + [416] = {.lex_state = 25, .external_lex_state = 2}, + [417] = {.lex_state = 25, .external_lex_state = 2}, + [418] = {.lex_state = 25, .external_lex_state = 2}, + [419] = {.lex_state = 25, .external_lex_state = 2}, + [420] = {.lex_state = 25, .external_lex_state = 2}, + [421] = {.lex_state = 25, .external_lex_state = 2}, + [422] = {.lex_state = 25, .external_lex_state = 2}, + [423] = {.lex_state = 25, .external_lex_state = 2}, + [424] = {.lex_state = 25, .external_lex_state = 2}, + [425] = {.lex_state = 25, .external_lex_state = 2}, + [426] = {.lex_state = 25, .external_lex_state = 2}, + [427] = {.lex_state = 25, .external_lex_state = 2}, + [428] = {.lex_state = 25, .external_lex_state = 2}, + [429] = {.lex_state = 25, .external_lex_state = 2}, + [430] = {.lex_state = 25, .external_lex_state = 2}, + [431] = {.lex_state = 25, .external_lex_state = 2}, + [432] = {.lex_state = 25, .external_lex_state = 2}, + [433] = {.lex_state = 25, .external_lex_state = 2}, + [434] = {.lex_state = 25, .external_lex_state = 2}, + [435] = {.lex_state = 100, .external_lex_state = 2}, + [436] = {.lex_state = 25, .external_lex_state = 2}, + [437] = {.lex_state = 100, .external_lex_state = 2}, + [438] = {.lex_state = 100, .external_lex_state = 2}, + [439] = {.lex_state = 100, .external_lex_state = 2}, + [440] = {.lex_state = 25, .external_lex_state = 2}, + [441] = {.lex_state = 100, .external_lex_state = 2}, + [442] = {.lex_state = 100, .external_lex_state = 2}, + [443] = {.lex_state = 102, .external_lex_state = 2}, + [444] = {.lex_state = 102, .external_lex_state = 2}, + [445] = {.lex_state = 101, .external_lex_state = 2}, + [446] = {.lex_state = 101, .external_lex_state = 2}, + [447] = {.lex_state = 101, .external_lex_state = 2}, + [448] = {.lex_state = 101, .external_lex_state = 2}, + [449] = {.lex_state = 101, .external_lex_state = 2}, + [450] = {.lex_state = 101, .external_lex_state = 2}, + [451] = {.lex_state = 101, .external_lex_state = 2}, + [452] = {.lex_state = 101, .external_lex_state = 2}, + [453] = {.lex_state = 101, .external_lex_state = 2}, + [454] = {.lex_state = 101, .external_lex_state = 2}, + [455] = {.lex_state = 100, .external_lex_state = 2}, + [456] = {.lex_state = 100, .external_lex_state = 2}, + [457] = {.lex_state = 100, .external_lex_state = 2}, + [458] = {.lex_state = 100, .external_lex_state = 2}, + [459] = {.lex_state = 10, .external_lex_state = 2}, + [460] = {.lex_state = 10, .external_lex_state = 2}, + [461] = {.lex_state = 100, .external_lex_state = 2}, + [462] = {.lex_state = 100, .external_lex_state = 2}, + [463] = {.lex_state = 100, .external_lex_state = 2}, + [464] = {.lex_state = 100, .external_lex_state = 2}, + [465] = {.lex_state = 100, .external_lex_state = 2}, + [466] = {.lex_state = 12, .external_lex_state = 2}, + [467] = {.lex_state = 101, .external_lex_state = 2}, + [468] = {.lex_state = 101, .external_lex_state = 2}, + [469] = {.lex_state = 12, .external_lex_state = 2}, + [470] = {.lex_state = 10, .external_lex_state = 2}, + [471] = {.lex_state = 10, .external_lex_state = 2}, + [472] = {.lex_state = 101, .external_lex_state = 2}, + [473] = {.lex_state = 101, .external_lex_state = 2}, + [474] = {.lex_state = 101, .external_lex_state = 2}, + [475] = {.lex_state = 6, .external_lex_state = 2}, + [476] = {.lex_state = 101, .external_lex_state = 2}, + [477] = {.lex_state = 101, .external_lex_state = 2}, + [478] = {.lex_state = 6, .external_lex_state = 2}, + [479] = {.lex_state = 101, .external_lex_state = 2}, + [480] = {.lex_state = 101, .external_lex_state = 2}, + [481] = {.lex_state = 101, .external_lex_state = 2}, + [482] = {.lex_state = 6, .external_lex_state = 2}, + [483] = {.lex_state = 10, .external_lex_state = 2}, + [484] = {.lex_state = 9, .external_lex_state = 2}, + [485] = {.lex_state = 12, .external_lex_state = 2}, + [486] = {.lex_state = 101, .external_lex_state = 2}, + [487] = {.lex_state = 12, .external_lex_state = 2}, + [488] = {.lex_state = 101, .external_lex_state = 2}, + [489] = {.lex_state = 101, .external_lex_state = 2}, + [490] = {.lex_state = 101, .external_lex_state = 2}, + [491] = {.lex_state = 101, .external_lex_state = 2}, + [492] = {.lex_state = 101, .external_lex_state = 2}, + [493] = {.lex_state = 101, .external_lex_state = 2}, + [494] = {.lex_state = 10, .external_lex_state = 2}, + [495] = {.lex_state = 10, .external_lex_state = 2}, + [496] = {.lex_state = 6, .external_lex_state = 2}, + [497] = {.lex_state = 6, .external_lex_state = 2}, + [498] = {.lex_state = 6, .external_lex_state = 2}, + [499] = {.lex_state = 6, .external_lex_state = 2}, + [500] = {.lex_state = 6, .external_lex_state = 2}, + [501] = {.lex_state = 6, .external_lex_state = 2}, + [502] = {.lex_state = 6, .external_lex_state = 2}, + [503] = {.lex_state = 6, .external_lex_state = 2}, + [504] = {.lex_state = 6, .external_lex_state = 2}, + [505] = {.lex_state = 6, .external_lex_state = 2}, + [506] = {.lex_state = 6, .external_lex_state = 2}, + [507] = {.lex_state = 10, .external_lex_state = 2}, + [508] = {.lex_state = 9, .external_lex_state = 2}, + [509] = {.lex_state = 9, .external_lex_state = 2}, + [510] = {.lex_state = 12, .external_lex_state = 2}, + [511] = {.lex_state = 7, .external_lex_state = 2}, + [512] = {.lex_state = 101, .external_lex_state = 2}, + [513] = {.lex_state = 101, .external_lex_state = 2}, + [514] = {.lex_state = 6, .external_lex_state = 2}, + [515] = {.lex_state = 9, .external_lex_state = 2}, + [516] = {.lex_state = 9, .external_lex_state = 2}, + [517] = {.lex_state = 9, .external_lex_state = 2}, + [518] = {.lex_state = 101, .external_lex_state = 2}, + [519] = {.lex_state = 101, .external_lex_state = 2}, + [520] = {.lex_state = 101, .external_lex_state = 2}, + [521] = {.lex_state = 101, .external_lex_state = 2}, + [522] = {.lex_state = 101, .external_lex_state = 2}, + [523] = {.lex_state = 101, .external_lex_state = 2}, + [524] = {.lex_state = 101, .external_lex_state = 2}, + [525] = {.lex_state = 9, .external_lex_state = 2}, + [526] = {.lex_state = 101, .external_lex_state = 2}, + [527] = {.lex_state = 101, .external_lex_state = 2}, + [528] = {.lex_state = 101, .external_lex_state = 2}, + [529] = {.lex_state = 101, .external_lex_state = 2}, + [530] = {.lex_state = 101, .external_lex_state = 2}, + [531] = {.lex_state = 101, .external_lex_state = 2}, + [532] = {.lex_state = 101, .external_lex_state = 2}, + [533] = {.lex_state = 100, .external_lex_state = 2}, + [534] = {.lex_state = 101, .external_lex_state = 2}, + [535] = {.lex_state = 101, .external_lex_state = 2}, + [536] = {.lex_state = 9, .external_lex_state = 2}, + [537] = {.lex_state = 101, .external_lex_state = 2}, + [538] = {.lex_state = 101, .external_lex_state = 2}, + [539] = {.lex_state = 101, .external_lex_state = 2}, + [540] = {.lex_state = 101, .external_lex_state = 2}, + [541] = {.lex_state = 101, .external_lex_state = 2}, + [542] = {.lex_state = 101, .external_lex_state = 2}, + [543] = {.lex_state = 101, .external_lex_state = 2}, + [544] = {.lex_state = 101, .external_lex_state = 2}, + [545] = {.lex_state = 101, .external_lex_state = 2}, + [546] = {.lex_state = 101, .external_lex_state = 2}, + [547] = {.lex_state = 101, .external_lex_state = 2}, + [548] = {.lex_state = 101, .external_lex_state = 2}, + [549] = {.lex_state = 101, .external_lex_state = 2}, + [550] = {.lex_state = 101, .external_lex_state = 2}, + [551] = {.lex_state = 101, .external_lex_state = 2}, + [552] = {.lex_state = 9, .external_lex_state = 2}, + [553] = {.lex_state = 101, .external_lex_state = 2}, + [554] = {.lex_state = 9, .external_lex_state = 2}, + [555] = {.lex_state = 9, .external_lex_state = 2}, + [556] = {.lex_state = 12, .external_lex_state = 2}, + [557] = {.lex_state = 12, .external_lex_state = 2}, + [558] = {.lex_state = 9, .external_lex_state = 2}, + [559] = {.lex_state = 9, .external_lex_state = 2}, + [560] = {.lex_state = 12, .external_lex_state = 2}, + [561] = {.lex_state = 100, .external_lex_state = 2}, + [562] = {.lex_state = 9, .external_lex_state = 2}, + [563] = {.lex_state = 7, .external_lex_state = 2}, + [564] = {.lex_state = 7, .external_lex_state = 2}, + [565] = {.lex_state = 7, .external_lex_state = 2}, + [566] = {.lex_state = 7, .external_lex_state = 2}, + [567] = {.lex_state = 7, .external_lex_state = 2}, + [568] = {.lex_state = 7, .external_lex_state = 2}, + [569] = {.lex_state = 7, .external_lex_state = 2}, + [570] = {.lex_state = 7, .external_lex_state = 2}, + [571] = {.lex_state = 7, .external_lex_state = 2}, + [572] = {.lex_state = 102, .external_lex_state = 2}, + [573] = {.lex_state = 7, .external_lex_state = 2}, + [574] = {.lex_state = 9, .external_lex_state = 2}, + [575] = {.lex_state = 7, .external_lex_state = 2}, + [576] = {.lex_state = 9, .external_lex_state = 2}, + [577] = {.lex_state = 101, .external_lex_state = 2}, + [578] = {.lex_state = 10, .external_lex_state = 2}, + [579] = {.lex_state = 101, .external_lex_state = 2}, + [580] = {.lex_state = 101, .external_lex_state = 2}, + [581] = {.lex_state = 101, .external_lex_state = 2}, + [582] = {.lex_state = 10, .external_lex_state = 2}, + [583] = {.lex_state = 101, .external_lex_state = 2}, + [584] = {.lex_state = 10, .external_lex_state = 2}, + [585] = {.lex_state = 101, .external_lex_state = 2}, + [586] = {.lex_state = 10, .external_lex_state = 2}, + [587] = {.lex_state = 10, .external_lex_state = 2}, + [588] = {.lex_state = 10, .external_lex_state = 2}, + [589] = {.lex_state = 101, .external_lex_state = 2}, + [590] = {.lex_state = 7, .external_lex_state = 2}, + [591] = {.lex_state = 101, .external_lex_state = 2}, + [592] = {.lex_state = 10, .external_lex_state = 2}, + [593] = {.lex_state = 10, .external_lex_state = 2}, + [594] = {.lex_state = 7, .external_lex_state = 2}, + [595] = {.lex_state = 101, .external_lex_state = 2}, + [596] = {.lex_state = 101, .external_lex_state = 2}, + [597] = {.lex_state = 101, .external_lex_state = 2}, + [598] = {.lex_state = 101, .external_lex_state = 2}, + [599] = {.lex_state = 10, .external_lex_state = 2}, + [600] = {.lex_state = 10, .external_lex_state = 2}, + [601] = {.lex_state = 10, .external_lex_state = 2}, + [602] = {.lex_state = 10, .external_lex_state = 2}, + [603] = {.lex_state = 10, .external_lex_state = 2}, + [604] = {.lex_state = 101, .external_lex_state = 2}, + [605] = {.lex_state = 11, .external_lex_state = 2}, + [606] = {.lex_state = 11, .external_lex_state = 2}, + [607] = {.lex_state = 6, .external_lex_state = 2}, + [608] = {.lex_state = 6, .external_lex_state = 2}, + [609] = {.lex_state = 11, .external_lex_state = 2}, + [610] = {.lex_state = 11, .external_lex_state = 2}, + [611] = {.lex_state = 11, .external_lex_state = 2}, + [612] = {.lex_state = 11, .external_lex_state = 2}, + [613] = {.lex_state = 11, .external_lex_state = 2}, + [614] = {.lex_state = 11, .external_lex_state = 2}, + [615] = {.lex_state = 11, .external_lex_state = 2}, + [616] = {.lex_state = 11, .external_lex_state = 2}, + [617] = {.lex_state = 9, .external_lex_state = 2}, + [618] = {.lex_state = 6, .external_lex_state = 2}, + [619] = {.lex_state = 6, .external_lex_state = 2}, + [620] = {.lex_state = 101, .external_lex_state = 2}, + [621] = {.lex_state = 9, .external_lex_state = 2}, + [622] = {.lex_state = 6, .external_lex_state = 2}, + [623] = {.lex_state = 6, .external_lex_state = 2}, + [624] = {.lex_state = 9, .external_lex_state = 2}, + [625] = {.lex_state = 6, .external_lex_state = 2}, + [626] = {.lex_state = 6, .external_lex_state = 2}, + [627] = {.lex_state = 6, .external_lex_state = 2}, + [628] = {.lex_state = 6, .external_lex_state = 2}, + [629] = {.lex_state = 6, .external_lex_state = 2}, + [630] = {.lex_state = 5, .external_lex_state = 2}, + [631] = {.lex_state = 5, .external_lex_state = 2}, + [632] = {.lex_state = 6, .external_lex_state = 2}, + [633] = {.lex_state = 6, .external_lex_state = 2}, + [634] = {.lex_state = 6, .external_lex_state = 2}, + [635] = {.lex_state = 6, .external_lex_state = 2}, + [636] = {.lex_state = 6, .external_lex_state = 2}, + [637] = {.lex_state = 6, .external_lex_state = 2}, + [638] = {.lex_state = 6, .external_lex_state = 2}, + [639] = {.lex_state = 12, .external_lex_state = 2}, + [640] = {.lex_state = 12, .external_lex_state = 2}, + [641] = {.lex_state = 12, .external_lex_state = 2}, + [642] = {.lex_state = 9, .external_lex_state = 2}, + [643] = {.lex_state = 6, .external_lex_state = 2}, + [644] = {.lex_state = 12, .external_lex_state = 2}, + [645] = {.lex_state = 12, .external_lex_state = 2}, + [646] = {.lex_state = 6, .external_lex_state = 2}, + [647] = {.lex_state = 9, .external_lex_state = 2}, + [648] = {.lex_state = 9, .external_lex_state = 2}, + [649] = {.lex_state = 12, .external_lex_state = 2}, + [650] = {.lex_state = 12, .external_lex_state = 2}, + [651] = {.lex_state = 9, .external_lex_state = 2}, + [652] = {.lex_state = 8, .external_lex_state = 2}, + [653] = {.lex_state = 12, .external_lex_state = 2}, + [654] = {.lex_state = 6, .external_lex_state = 2}, + [655] = {.lex_state = 12, .external_lex_state = 2}, + [656] = {.lex_state = 9, .external_lex_state = 2}, + [657] = {.lex_state = 12, .external_lex_state = 2}, + [658] = {.lex_state = 12, .external_lex_state = 2}, + [659] = {.lex_state = 12, .external_lex_state = 2}, + [660] = {.lex_state = 12, .external_lex_state = 2}, + [661] = {.lex_state = 8, .external_lex_state = 2}, + [662] = {.lex_state = 8, .external_lex_state = 2}, + [663] = {.lex_state = 6, .external_lex_state = 2}, + [664] = {.lex_state = 8, .external_lex_state = 2}, + [665] = {.lex_state = 6, .external_lex_state = 2}, + [666] = {.lex_state = 6, .external_lex_state = 2}, + [667] = {.lex_state = 6, .external_lex_state = 2}, + [668] = {.lex_state = 6, .external_lex_state = 2}, + [669] = {.lex_state = 8, .external_lex_state = 2}, + [670] = {.lex_state = 8, .external_lex_state = 2}, + [671] = {.lex_state = 6, .external_lex_state = 2}, + [672] = {.lex_state = 100, .external_lex_state = 2}, + [673] = {.lex_state = 8, .external_lex_state = 2}, + [674] = {.lex_state = 27, .external_lex_state = 2}, + [675] = {.lex_state = 6, .external_lex_state = 2}, + [676] = {.lex_state = 8, .external_lex_state = 2}, + [677] = {.lex_state = 9, .external_lex_state = 2}, + [678] = {.lex_state = 8, .external_lex_state = 2}, + [679] = {.lex_state = 6, .external_lex_state = 2}, + [680] = {.lex_state = 6, .external_lex_state = 2}, + [681] = {.lex_state = 9, .external_lex_state = 2}, + [682] = {.lex_state = 100, .external_lex_state = 2}, + [683] = {.lex_state = 27, .external_lex_state = 2}, + [684] = {.lex_state = 101, .external_lex_state = 2}, + [685] = {.lex_state = 101, .external_lex_state = 2}, + [686] = {.lex_state = 27, .external_lex_state = 2}, + [687] = {.lex_state = 28, .external_lex_state = 2}, + [688] = {.lex_state = 27, .external_lex_state = 2}, + [689] = {.lex_state = 7, .external_lex_state = 2}, + [690] = {.lex_state = 7, .external_lex_state = 2}, + [691] = {.lex_state = 7, .external_lex_state = 2}, + [692] = {.lex_state = 27, .external_lex_state = 2}, + [693] = {.lex_state = 27, .external_lex_state = 2}, + [694] = {.lex_state = 7, .external_lex_state = 2}, + [695] = {.lex_state = 28, .external_lex_state = 2}, + [696] = {.lex_state = 27, .external_lex_state = 2}, + [697] = {.lex_state = 27, .external_lex_state = 2}, + [698] = {.lex_state = 7, .external_lex_state = 2}, + [699] = {.lex_state = 7, .external_lex_state = 2}, + [700] = {.lex_state = 27, .external_lex_state = 2}, + [701] = {.lex_state = 101, .external_lex_state = 2}, + [702] = {.lex_state = 27, .external_lex_state = 2}, + [703] = {.lex_state = 27, .external_lex_state = 2}, + [704] = {.lex_state = 27, .external_lex_state = 2}, + [705] = {.lex_state = 7, .external_lex_state = 2}, + [706] = {.lex_state = 101, .external_lex_state = 2}, + [707] = {.lex_state = 7, .external_lex_state = 2}, + [708] = {.lex_state = 7, .external_lex_state = 2}, + [709] = {.lex_state = 7, .external_lex_state = 2}, + [710] = {.lex_state = 7, .external_lex_state = 2}, + [711] = {.lex_state = 7, .external_lex_state = 2}, + [712] = {.lex_state = 7, .external_lex_state = 2}, + [713] = {.lex_state = 28, .external_lex_state = 2}, + [714] = {.lex_state = 28, .external_lex_state = 2}, + [715] = {.lex_state = 28, .external_lex_state = 2}, + [716] = {.lex_state = 5, .external_lex_state = 2}, + [717] = {.lex_state = 5, .external_lex_state = 2}, + [718] = {.lex_state = 28, .external_lex_state = 2}, + [719] = {.lex_state = 28, .external_lex_state = 2}, + [720] = {.lex_state = 28, .external_lex_state = 2}, + [721] = {.lex_state = 28, .external_lex_state = 2}, + [722] = {.lex_state = 6, .external_lex_state = 2}, + [723] = {.lex_state = 28, .external_lex_state = 2}, + [724] = {.lex_state = 28, .external_lex_state = 2}, + [725] = {.lex_state = 28, .external_lex_state = 2}, + [726] = {.lex_state = 5, .external_lex_state = 2}, + [727] = {.lex_state = 5, .external_lex_state = 2}, + [728] = {.lex_state = 28, .external_lex_state = 2}, + [729] = {.lex_state = 7, .external_lex_state = 2}, + [730] = {.lex_state = 7, .external_lex_state = 2}, + [731] = {.lex_state = 7, .external_lex_state = 2}, + [732] = {.lex_state = 7, .external_lex_state = 2}, + [733] = {.lex_state = 7, .external_lex_state = 2}, + [734] = {.lex_state = 7, .external_lex_state = 2}, + [735] = {.lex_state = 5, .external_lex_state = 2}, + [736] = {.lex_state = 5, .external_lex_state = 2}, + [737] = {.lex_state = 7, .external_lex_state = 2}, + [738] = {.lex_state = 7, .external_lex_state = 2}, + [739] = {.lex_state = 7, .external_lex_state = 2}, + [740] = {.lex_state = 7, .external_lex_state = 2}, + [741] = {.lex_state = 7, .external_lex_state = 2}, + [742] = {.lex_state = 7, .external_lex_state = 2}, + [743] = {.lex_state = 7, .external_lex_state = 2}, + [744] = {.lex_state = 5, .external_lex_state = 2}, + [745] = {.lex_state = 5, .external_lex_state = 2}, + [746] = {.lex_state = 5, .external_lex_state = 2}, + [747] = {.lex_state = 7, .external_lex_state = 2}, + [748] = {.lex_state = 101, .external_lex_state = 2}, + [749] = {.lex_state = 7, .external_lex_state = 2}, + [750] = {.lex_state = 7, .external_lex_state = 2}, + [751] = {.lex_state = 7, .external_lex_state = 2}, + [752] = {.lex_state = 6, .external_lex_state = 2}, + [753] = {.lex_state = 26, .external_lex_state = 2}, + [754] = {.lex_state = 26, .external_lex_state = 2}, + [755] = {.lex_state = 26, .external_lex_state = 2}, + [756] = {.lex_state = 6, .external_lex_state = 2}, + [757] = {.lex_state = 6, .external_lex_state = 2}, + [758] = {.lex_state = 6, .external_lex_state = 2}, + [759] = {.lex_state = 101, .external_lex_state = 2}, + [760] = {.lex_state = 26, .external_lex_state = 2}, + [761] = {.lex_state = 101, .external_lex_state = 2}, + [762] = {.lex_state = 23, .external_lex_state = 2}, + [763] = {.lex_state = 26, .external_lex_state = 2}, + [764] = {.lex_state = 26, .external_lex_state = 2}, + [765] = {.lex_state = 6, .external_lex_state = 2}, + [766] = {.lex_state = 6, .external_lex_state = 2}, + [767] = {.lex_state = 26, .external_lex_state = 2}, + [768] = {.lex_state = 23, .external_lex_state = 2}, + [769] = {.lex_state = 26, .external_lex_state = 2}, + [770] = {.lex_state = 26, .external_lex_state = 2}, + [771] = {.lex_state = 26, .external_lex_state = 2}, + [772] = {.lex_state = 6, .external_lex_state = 2}, + [773] = {.lex_state = 26, .external_lex_state = 2}, + [774] = {.lex_state = 6, .external_lex_state = 2}, + [775] = {.lex_state = 6, .external_lex_state = 2}, + [776] = {.lex_state = 6, .external_lex_state = 2}, + [777] = {.lex_state = 6, .external_lex_state = 2}, + [778] = {.lex_state = 6, .external_lex_state = 2}, + [779] = {.lex_state = 6, .external_lex_state = 2}, + [780] = {.lex_state = 6, .external_lex_state = 2}, + [781] = {.lex_state = 6, .external_lex_state = 2}, + [782] = {.lex_state = 6, .external_lex_state = 2}, + [783] = {.lex_state = 26, .external_lex_state = 2}, + [784] = {.lex_state = 5, .external_lex_state = 2}, + [785] = {.lex_state = 5, .external_lex_state = 2}, + [786] = {.lex_state = 6, .external_lex_state = 2}, + [787] = {.lex_state = 101, .external_lex_state = 2}, + [788] = {.lex_state = 6, .external_lex_state = 2}, + [789] = {.lex_state = 6, .external_lex_state = 2}, + [790] = {.lex_state = 5, .external_lex_state = 2}, + [791] = {.lex_state = 5, .external_lex_state = 2}, + [792] = {.lex_state = 5, .external_lex_state = 2}, + [793] = {.lex_state = 5, .external_lex_state = 2}, + [794] = {.lex_state = 5, .external_lex_state = 2}, + [795] = {.lex_state = 5, .external_lex_state = 2}, + [796] = {.lex_state = 5, .external_lex_state = 2}, + [797] = {.lex_state = 5, .external_lex_state = 2}, + [798] = {.lex_state = 6, .external_lex_state = 2}, + [799] = {.lex_state = 5, .external_lex_state = 2}, + [800] = {.lex_state = 101, .external_lex_state = 2}, + [801] = {.lex_state = 6, .external_lex_state = 2}, + [802] = {.lex_state = 6, .external_lex_state = 2}, + [803] = {.lex_state = 6, .external_lex_state = 2}, + [804] = {.lex_state = 6, .external_lex_state = 2}, + [805] = {.lex_state = 27, .external_lex_state = 2}, + [806] = {.lex_state = 6, .external_lex_state = 2}, + [807] = {.lex_state = 27, .external_lex_state = 2}, + [808] = {.lex_state = 5, .external_lex_state = 2}, + [809] = {.lex_state = 6, .external_lex_state = 2}, + [810] = {.lex_state = 5, .external_lex_state = 2}, + [811] = {.lex_state = 5, .external_lex_state = 2}, + [812] = {.lex_state = 5, .external_lex_state = 2}, + [813] = {.lex_state = 5, .external_lex_state = 2}, + [814] = {.lex_state = 5, .external_lex_state = 2}, + [815] = {.lex_state = 101, .external_lex_state = 2}, + [816] = {.lex_state = 6, .external_lex_state = 2}, + [817] = {.lex_state = 6, .external_lex_state = 2}, + [818] = {.lex_state = 6, .external_lex_state = 2}, + [819] = {.lex_state = 6, .external_lex_state = 2}, + [820] = {.lex_state = 14, .external_lex_state = 2}, + [821] = {.lex_state = 6, .external_lex_state = 2}, + [822] = {.lex_state = 6, .external_lex_state = 2}, + [823] = {.lex_state = 6, .external_lex_state = 2}, + [824] = {.lex_state = 6, .external_lex_state = 2}, + [825] = {.lex_state = 101, .external_lex_state = 2}, + [826] = {.lex_state = 6, .external_lex_state = 2}, + [827] = {.lex_state = 22, .external_lex_state = 2}, + [828] = {.lex_state = 6, .external_lex_state = 2}, + [829] = {.lex_state = 22, .external_lex_state = 2}, + [830] = {.lex_state = 101, .external_lex_state = 2}, + [831] = {.lex_state = 101, .external_lex_state = 2}, + [832] = {.lex_state = 6, .external_lex_state = 2}, + [833] = {.lex_state = 6, .external_lex_state = 2}, + [834] = {.lex_state = 6, .external_lex_state = 2}, + [835] = {.lex_state = 6, .external_lex_state = 2}, + [836] = {.lex_state = 6, .external_lex_state = 2}, + [837] = {.lex_state = 6, .external_lex_state = 2}, + [838] = {.lex_state = 6, .external_lex_state = 2}, + [839] = {.lex_state = 6, .external_lex_state = 2}, + [840] = {.lex_state = 6, .external_lex_state = 2}, + [841] = {.lex_state = 6, .external_lex_state = 2}, + [842] = {.lex_state = 6, .external_lex_state = 2}, + [843] = {.lex_state = 6, .external_lex_state = 2}, + [844] = {.lex_state = 14, .external_lex_state = 2}, + [845] = {.lex_state = 14, .external_lex_state = 2}, + [846] = {.lex_state = 14, .external_lex_state = 2}, + [847] = {.lex_state = 14, .external_lex_state = 2}, + [848] = {.lex_state = 6, .external_lex_state = 2}, + [849] = {.lex_state = 6, .external_lex_state = 2}, + [850] = {.lex_state = 6, .external_lex_state = 2}, + [851] = {.lex_state = 6, .external_lex_state = 2}, + [852] = {.lex_state = 14, .external_lex_state = 2}, + [853] = {.lex_state = 14, .external_lex_state = 2}, + [854] = {.lex_state = 14, .external_lex_state = 2}, + [855] = {.lex_state = 14, .external_lex_state = 2}, + [856] = {.lex_state = 6, .external_lex_state = 2}, + [857] = {.lex_state = 6, .external_lex_state = 2}, + [858] = {.lex_state = 6, .external_lex_state = 2}, + [859] = {.lex_state = 6, .external_lex_state = 2}, + [860] = {.lex_state = 6, .external_lex_state = 2}, + [861] = {.lex_state = 6, .external_lex_state = 2}, + [862] = {.lex_state = 6, .external_lex_state = 2}, + [863] = {.lex_state = 6, .external_lex_state = 2}, + [864] = {.lex_state = 6, .external_lex_state = 2}, + [865] = {.lex_state = 6, .external_lex_state = 2}, + [866] = {.lex_state = 6, .external_lex_state = 2}, + [867] = {.lex_state = 6, .external_lex_state = 2}, + [868] = {.lex_state = 6, .external_lex_state = 2}, + [869] = {.lex_state = 6, .external_lex_state = 2}, + [870] = {.lex_state = 6, .external_lex_state = 2}, + [871] = {.lex_state = 6, .external_lex_state = 2}, + [872] = {.lex_state = 6, .external_lex_state = 2}, + [873] = {.lex_state = 6, .external_lex_state = 2}, + [874] = {.lex_state = 6, .external_lex_state = 2}, + [875] = {.lex_state = 6, .external_lex_state = 2}, + [876] = {.lex_state = 101, .external_lex_state = 2}, + [877] = {.lex_state = 6, .external_lex_state = 2}, + [878] = {.lex_state = 6, .external_lex_state = 2}, + [879] = {.lex_state = 6, .external_lex_state = 2}, + [880] = {.lex_state = 6, .external_lex_state = 2}, + [881] = {.lex_state = 6, .external_lex_state = 2}, + [882] = {.lex_state = 6, .external_lex_state = 2}, + [883] = {.lex_state = 6, .external_lex_state = 2}, + [884] = {.lex_state = 6, .external_lex_state = 2}, + [885] = {.lex_state = 6, .external_lex_state = 2}, + [886] = {.lex_state = 6, .external_lex_state = 2}, + [887] = {.lex_state = 22, .external_lex_state = 2}, + [888] = {.lex_state = 7, .external_lex_state = 2}, + [889] = {.lex_state = 7, .external_lex_state = 2}, + [890] = {.lex_state = 7, .external_lex_state = 2}, + [891] = {.lex_state = 7, .external_lex_state = 2}, + [892] = {.lex_state = 7, .external_lex_state = 2}, + [893] = {.lex_state = 6, .external_lex_state = 2}, + [894] = {.lex_state = 101, .external_lex_state = 2}, + [895] = {.lex_state = 6, .external_lex_state = 2}, + [896] = {.lex_state = 6, .external_lex_state = 2}, + [897] = {.lex_state = 6, .external_lex_state = 2}, + [898] = {.lex_state = 6, .external_lex_state = 2}, + [899] = {.lex_state = 6, .external_lex_state = 2}, + [900] = {.lex_state = 6, .external_lex_state = 2}, + [901] = {.lex_state = 6, .external_lex_state = 2}, + [902] = {.lex_state = 6, .external_lex_state = 2}, + [903] = {.lex_state = 6, .external_lex_state = 2}, + [904] = {.lex_state = 6, .external_lex_state = 2}, + [905] = {.lex_state = 6, .external_lex_state = 2}, + [906] = {.lex_state = 6, .external_lex_state = 2}, + [907] = {.lex_state = 6, .external_lex_state = 2}, + [908] = {.lex_state = 6, .external_lex_state = 2}, + [909] = {.lex_state = 6, .external_lex_state = 2}, + [910] = {.lex_state = 6, .external_lex_state = 2}, + [911] = {.lex_state = 6, .external_lex_state = 2}, + [912] = {.lex_state = 22, .external_lex_state = 2}, + [913] = {.lex_state = 6, .external_lex_state = 2}, + [914] = {.lex_state = 6, .external_lex_state = 2}, + [915] = {.lex_state = 6, .external_lex_state = 2}, + [916] = {.lex_state = 6, .external_lex_state = 2}, + [917] = {.lex_state = 6, .external_lex_state = 2}, + [918] = {.lex_state = 6, .external_lex_state = 2}, + [919] = {.lex_state = 6, .external_lex_state = 2}, + [920] = {.lex_state = 6, .external_lex_state = 2}, + [921] = {.lex_state = 6, .external_lex_state = 2}, + [922] = {.lex_state = 6, .external_lex_state = 2}, + [923] = {.lex_state = 6, .external_lex_state = 2}, + [924] = {.lex_state = 6, .external_lex_state = 2}, + [925] = {.lex_state = 6, .external_lex_state = 2}, + [926] = {.lex_state = 6, .external_lex_state = 2}, + [927] = {.lex_state = 6, .external_lex_state = 2}, + [928] = {.lex_state = 6, .external_lex_state = 2}, + [929] = {.lex_state = 6, .external_lex_state = 2}, + [930] = {.lex_state = 6, .external_lex_state = 2}, + [931] = {.lex_state = 6, .external_lex_state = 2}, + [932] = {.lex_state = 6, .external_lex_state = 2}, + [933] = {.lex_state = 6, .external_lex_state = 2}, + [934] = {.lex_state = 6, .external_lex_state = 2}, + [935] = {.lex_state = 6, .external_lex_state = 2}, + [936] = {.lex_state = 6, .external_lex_state = 2}, + [937] = {.lex_state = 6, .external_lex_state = 2}, + [938] = {.lex_state = 6, .external_lex_state = 2}, + [939] = {.lex_state = 6, .external_lex_state = 2}, + [940] = {.lex_state = 6, .external_lex_state = 2}, + [941] = {.lex_state = 6, .external_lex_state = 2}, + [942] = {.lex_state = 6, .external_lex_state = 2}, + [943] = {.lex_state = 6, .external_lex_state = 2}, + [944] = {.lex_state = 6, .external_lex_state = 2}, + [945] = {.lex_state = 6, .external_lex_state = 2}, + [946] = {.lex_state = 6, .external_lex_state = 2}, + [947] = {.lex_state = 6, .external_lex_state = 2}, + [948] = {.lex_state = 7, .external_lex_state = 2}, + [949] = {.lex_state = 6, .external_lex_state = 2}, + [950] = {.lex_state = 6, .external_lex_state = 2}, + [951] = {.lex_state = 7, .external_lex_state = 2}, + [952] = {.lex_state = 6, .external_lex_state = 2}, + [953] = {.lex_state = 22, .external_lex_state = 2}, + [954] = {.lex_state = 6, .external_lex_state = 2}, + [955] = {.lex_state = 22, .external_lex_state = 2}, + [956] = {.lex_state = 6, .external_lex_state = 2}, + [957] = {.lex_state = 7, .external_lex_state = 2}, + [958] = {.lex_state = 7, .external_lex_state = 2}, + [959] = {.lex_state = 6, .external_lex_state = 2}, + [960] = {.lex_state = 7, .external_lex_state = 2}, + [961] = {.lex_state = 6, .external_lex_state = 2}, + [962] = {.lex_state = 6, .external_lex_state = 2}, + [963] = {.lex_state = 7, .external_lex_state = 2}, + [964] = {.lex_state = 6, .external_lex_state = 2}, + [965] = {.lex_state = 7, .external_lex_state = 2}, + [966] = {.lex_state = 7, .external_lex_state = 2}, + [967] = {.lex_state = 7, .external_lex_state = 2}, + [968] = {.lex_state = 7, .external_lex_state = 2}, + [969] = {.lex_state = 6, .external_lex_state = 2}, + [970] = {.lex_state = 6, .external_lex_state = 2}, + [971] = {.lex_state = 6, .external_lex_state = 2}, + [972] = {.lex_state = 6, .external_lex_state = 2}, + [973] = {.lex_state = 101, .external_lex_state = 2}, + [974] = {.lex_state = 6, .external_lex_state = 2}, + [975] = {.lex_state = 6, .external_lex_state = 2}, + [976] = {.lex_state = 6, .external_lex_state = 2}, + [977] = {.lex_state = 6, .external_lex_state = 2}, + [978] = {.lex_state = 6, .external_lex_state = 2}, + [979] = {.lex_state = 6, .external_lex_state = 2}, + [980] = {.lex_state = 6, .external_lex_state = 2}, + [981] = {.lex_state = 6, .external_lex_state = 2}, + [982] = {.lex_state = 6, .external_lex_state = 2}, + [983] = {.lex_state = 101, .external_lex_state = 2}, + [984] = {.lex_state = 6, .external_lex_state = 2}, + [985] = {.lex_state = 6, .external_lex_state = 2}, + [986] = {.lex_state = 101, .external_lex_state = 2}, + [987] = {.lex_state = 6, .external_lex_state = 2}, + [988] = {.lex_state = 6, .external_lex_state = 2}, + [989] = {.lex_state = 6, .external_lex_state = 2}, + [990] = {.lex_state = 6, .external_lex_state = 2}, + [991] = {.lex_state = 6, .external_lex_state = 2}, + [992] = {.lex_state = 6, .external_lex_state = 2}, + [993] = {.lex_state = 6, .external_lex_state = 2}, + [994] = {.lex_state = 6, .external_lex_state = 2}, + [995] = {.lex_state = 6, .external_lex_state = 2}, + [996] = {.lex_state = 6, .external_lex_state = 2}, + [997] = {.lex_state = 6, .external_lex_state = 2}, + [998] = {.lex_state = 6, .external_lex_state = 2}, + [999] = {.lex_state = 6, .external_lex_state = 2}, + [1000] = {.lex_state = 6, .external_lex_state = 2}, + [1001] = {.lex_state = 6, .external_lex_state = 2}, + [1002] = {.lex_state = 6, .external_lex_state = 2}, + [1003] = {.lex_state = 6, .external_lex_state = 2}, + [1004] = {.lex_state = 6, .external_lex_state = 2}, + [1005] = {.lex_state = 6, .external_lex_state = 2}, + [1006] = {.lex_state = 6, .external_lex_state = 2}, + [1007] = {.lex_state = 7, .external_lex_state = 2}, + [1008] = {.lex_state = 7, .external_lex_state = 2}, + [1009] = {.lex_state = 7, .external_lex_state = 2}, + [1010] = {.lex_state = 7, .external_lex_state = 2}, + [1011] = {.lex_state = 6, .external_lex_state = 2}, + [1012] = {.lex_state = 6, .external_lex_state = 2}, + [1013] = {.lex_state = 7, .external_lex_state = 2}, + [1014] = {.lex_state = 7, .external_lex_state = 2}, + [1015] = {.lex_state = 15, .external_lex_state = 2}, + [1016] = {.lex_state = 6, .external_lex_state = 2}, + [1017] = {.lex_state = 7, .external_lex_state = 2}, + [1018] = {.lex_state = 7, .external_lex_state = 2}, + [1019] = {.lex_state = 7, .external_lex_state = 2}, + [1020] = {.lex_state = 7, .external_lex_state = 2}, + [1021] = {.lex_state = 7, .external_lex_state = 2}, + [1022] = {.lex_state = 7, .external_lex_state = 2}, + [1023] = {.lex_state = 7, .external_lex_state = 2}, + [1024] = {.lex_state = 7, .external_lex_state = 2}, + [1025] = {.lex_state = 6, .external_lex_state = 2}, + [1026] = {.lex_state = 6, .external_lex_state = 2}, + [1027] = {.lex_state = 7, .external_lex_state = 2}, + [1028] = {.lex_state = 7, .external_lex_state = 2}, + [1029] = {.lex_state = 7, .external_lex_state = 2}, + [1030] = {.lex_state = 7, .external_lex_state = 2}, + [1031] = {.lex_state = 7, .external_lex_state = 2}, + [1032] = {.lex_state = 7, .external_lex_state = 2}, + [1033] = {.lex_state = 23, .external_lex_state = 2}, + [1034] = {.lex_state = 7, .external_lex_state = 2}, + [1035] = {.lex_state = 100, .external_lex_state = 2}, + [1036] = {.lex_state = 15, .external_lex_state = 2}, + [1037] = {.lex_state = 15, .external_lex_state = 2}, + [1038] = {.lex_state = 15, .external_lex_state = 2}, + [1039] = {.lex_state = 7, .external_lex_state = 2}, + [1040] = {.lex_state = 7, .external_lex_state = 2}, + [1041] = {.lex_state = 15, .external_lex_state = 2}, + [1042] = {.lex_state = 15, .external_lex_state = 2}, + [1043] = {.lex_state = 7, .external_lex_state = 2}, + [1044] = {.lex_state = 15, .external_lex_state = 2}, + [1045] = {.lex_state = 15, .external_lex_state = 2}, + [1046] = {.lex_state = 7, .external_lex_state = 2}, + [1047] = {.lex_state = 15, .external_lex_state = 2}, + [1048] = {.lex_state = 7, .external_lex_state = 2}, + [1049] = {.lex_state = 7, .external_lex_state = 2}, + [1050] = {.lex_state = 7, .external_lex_state = 2}, + [1051] = {.lex_state = 7, .external_lex_state = 2}, + [1052] = {.lex_state = 7, .external_lex_state = 2}, + [1053] = {.lex_state = 7, .external_lex_state = 2}, + [1054] = {.lex_state = 7, .external_lex_state = 2}, + [1055] = {.lex_state = 7, .external_lex_state = 2}, + [1056] = {.lex_state = 7, .external_lex_state = 2}, + [1057] = {.lex_state = 7, .external_lex_state = 2}, + [1058] = {.lex_state = 7, .external_lex_state = 2}, + [1059] = {.lex_state = 101, .external_lex_state = 2}, + [1060] = {.lex_state = 7, .external_lex_state = 2}, + [1061] = {.lex_state = 7, .external_lex_state = 2}, + [1062] = {.lex_state = 7, .external_lex_state = 2}, + [1063] = {.lex_state = 7, .external_lex_state = 2}, + [1064] = {.lex_state = 7, .external_lex_state = 2}, + [1065] = {.lex_state = 7, .external_lex_state = 2}, + [1066] = {.lex_state = 7, .external_lex_state = 2}, + [1067] = {.lex_state = 7, .external_lex_state = 2}, + [1068] = {.lex_state = 7, .external_lex_state = 2}, + [1069] = {.lex_state = 7, .external_lex_state = 2}, + [1070] = {.lex_state = 101, .external_lex_state = 2}, + [1071] = {.lex_state = 7, .external_lex_state = 2}, + [1072] = {.lex_state = 7, .external_lex_state = 2}, + [1073] = {.lex_state = 7, .external_lex_state = 2}, + [1074] = {.lex_state = 7, .external_lex_state = 2}, + [1075] = {.lex_state = 7, .external_lex_state = 2}, + [1076] = {.lex_state = 7, .external_lex_state = 2}, + [1077] = {.lex_state = 7, .external_lex_state = 2}, + [1078] = {.lex_state = 101, .external_lex_state = 2}, + [1079] = {.lex_state = 7, .external_lex_state = 2}, + [1080] = {.lex_state = 7, .external_lex_state = 2}, + [1081] = {.lex_state = 23, .external_lex_state = 2}, + [1082] = {.lex_state = 7, .external_lex_state = 2}, + [1083] = {.lex_state = 7, .external_lex_state = 2}, + [1084] = {.lex_state = 7, .external_lex_state = 2}, + [1085] = {.lex_state = 102, .external_lex_state = 2}, + [1086] = {.lex_state = 7, .external_lex_state = 2}, + [1087] = {.lex_state = 7, .external_lex_state = 2}, + [1088] = {.lex_state = 7, .external_lex_state = 2}, + [1089] = {.lex_state = 7, .external_lex_state = 2}, + [1090] = {.lex_state = 7, .external_lex_state = 2}, + [1091] = {.lex_state = 27, .external_lex_state = 2}, + [1092] = {.lex_state = 7, .external_lex_state = 2}, + [1093] = {.lex_state = 7, .external_lex_state = 2}, + [1094] = {.lex_state = 7, .external_lex_state = 2}, + [1095] = {.lex_state = 7, .external_lex_state = 2}, + [1096] = {.lex_state = 7, .external_lex_state = 2}, + [1097] = {.lex_state = 7, .external_lex_state = 2}, + [1098] = {.lex_state = 7, .external_lex_state = 2}, + [1099] = {.lex_state = 7, .external_lex_state = 2}, + [1100] = {.lex_state = 7, .external_lex_state = 2}, + [1101] = {.lex_state = 7, .external_lex_state = 2}, + [1102] = {.lex_state = 7, .external_lex_state = 2}, + [1103] = {.lex_state = 7, .external_lex_state = 2}, + [1104] = {.lex_state = 7, .external_lex_state = 2}, + [1105] = {.lex_state = 7, .external_lex_state = 2}, + [1106] = {.lex_state = 7, .external_lex_state = 2}, + [1107] = {.lex_state = 7, .external_lex_state = 2}, + [1108] = {.lex_state = 100, .external_lex_state = 2}, + [1109] = {.lex_state = 7, .external_lex_state = 2}, + [1110] = {.lex_state = 7, .external_lex_state = 2}, + [1111] = {.lex_state = 7, .external_lex_state = 2}, + [1112] = {.lex_state = 7, .external_lex_state = 2}, + [1113] = {.lex_state = 101, .external_lex_state = 2}, + [1114] = {.lex_state = 7, .external_lex_state = 2}, + [1115] = {.lex_state = 100, .external_lex_state = 2}, + [1116] = {.lex_state = 7, .external_lex_state = 2}, + [1117] = {.lex_state = 7, .external_lex_state = 2}, + [1118] = {.lex_state = 7, .external_lex_state = 2}, + [1119] = {.lex_state = 7, .external_lex_state = 2}, + [1120] = {.lex_state = 7, .external_lex_state = 2}, + [1121] = {.lex_state = 7, .external_lex_state = 2}, + [1122] = {.lex_state = 7, .external_lex_state = 2}, + [1123] = {.lex_state = 7, .external_lex_state = 2}, + [1124] = {.lex_state = 7, .external_lex_state = 2}, + [1125] = {.lex_state = 22, .external_lex_state = 2}, + [1126] = {.lex_state = 7, .external_lex_state = 2}, + [1127] = {.lex_state = 7, .external_lex_state = 2}, + [1128] = {.lex_state = 7, .external_lex_state = 2}, + [1129] = {.lex_state = 22, .external_lex_state = 2}, + [1130] = {.lex_state = 7, .external_lex_state = 2}, + [1131] = {.lex_state = 7, .external_lex_state = 2}, + [1132] = {.lex_state = 7, .external_lex_state = 2}, + [1133] = {.lex_state = 7, .external_lex_state = 2}, + [1134] = {.lex_state = 7, .external_lex_state = 2}, + [1135] = {.lex_state = 7, .external_lex_state = 2}, + [1136] = {.lex_state = 22, .external_lex_state = 2}, + [1137] = {.lex_state = 7, .external_lex_state = 2}, + [1138] = {.lex_state = 13, .external_lex_state = 2}, + [1139] = {.lex_state = 7, .external_lex_state = 2}, + [1140] = {.lex_state = 7, .external_lex_state = 2}, + [1141] = {.lex_state = 7, .external_lex_state = 2}, + [1142] = {.lex_state = 22, .external_lex_state = 2}, + [1143] = {.lex_state = 22, .external_lex_state = 2}, + [1144] = {.lex_state = 7, .external_lex_state = 2}, + [1145] = {.lex_state = 7, .external_lex_state = 2}, + [1146] = {.lex_state = 22, .external_lex_state = 2}, + [1147] = {.lex_state = 22, .external_lex_state = 2}, + [1148] = {.lex_state = 7, .external_lex_state = 2}, + [1149] = {.lex_state = 7, .external_lex_state = 2}, + [1150] = {.lex_state = 7, .external_lex_state = 2}, + [1151] = {.lex_state = 7, .external_lex_state = 2}, + [1152] = {.lex_state = 7, .external_lex_state = 2}, + [1153] = {.lex_state = 7, .external_lex_state = 2}, + [1154] = {.lex_state = 7, .external_lex_state = 2}, + [1155] = {.lex_state = 7, .external_lex_state = 2}, + [1156] = {.lex_state = 22, .external_lex_state = 2}, + [1157] = {.lex_state = 7, .external_lex_state = 2}, + [1158] = {.lex_state = 7, .external_lex_state = 2}, + [1159] = {.lex_state = 22, .external_lex_state = 2}, + [1160] = {.lex_state = 22, .external_lex_state = 2}, + [1161] = {.lex_state = 7, .external_lex_state = 2}, + [1162] = {.lex_state = 7, .external_lex_state = 2}, + [1163] = {.lex_state = 7, .external_lex_state = 2}, + [1164] = {.lex_state = 7, .external_lex_state = 2}, + [1165] = {.lex_state = 7, .external_lex_state = 2}, + [1166] = {.lex_state = 7, .external_lex_state = 2}, + [1167] = {.lex_state = 7, .external_lex_state = 2}, + [1168] = {.lex_state = 7, .external_lex_state = 2}, + [1169] = {.lex_state = 7, .external_lex_state = 2}, + [1170] = {.lex_state = 7, .external_lex_state = 2}, + [1171] = {.lex_state = 7, .external_lex_state = 2}, + [1172] = {.lex_state = 7, .external_lex_state = 2}, + [1173] = {.lex_state = 7, .external_lex_state = 2}, + [1174] = {.lex_state = 7, .external_lex_state = 2}, + [1175] = {.lex_state = 7, .external_lex_state = 2}, + [1176] = {.lex_state = 7, .external_lex_state = 2}, + [1177] = {.lex_state = 22, .external_lex_state = 2}, + [1178] = {.lex_state = 7, .external_lex_state = 2}, + [1179] = {.lex_state = 27, .external_lex_state = 2}, + [1180] = {.lex_state = 7, .external_lex_state = 2}, + [1181] = {.lex_state = 7, .external_lex_state = 2}, + [1182] = {.lex_state = 7, .external_lex_state = 2}, + [1183] = {.lex_state = 7, .external_lex_state = 2}, + [1184] = {.lex_state = 7, .external_lex_state = 2}, + [1185] = {.lex_state = 22, .external_lex_state = 2}, + [1186] = {.lex_state = 7, .external_lex_state = 2}, + [1187] = {.lex_state = 7, .external_lex_state = 2}, + [1188] = {.lex_state = 7, .external_lex_state = 2}, + [1189] = {.lex_state = 7, .external_lex_state = 2}, + [1190] = {.lex_state = 7, .external_lex_state = 2}, + [1191] = {.lex_state = 7, .external_lex_state = 2}, + [1192] = {.lex_state = 7, .external_lex_state = 2}, + [1193] = {.lex_state = 7, .external_lex_state = 2}, + [1194] = {.lex_state = 7, .external_lex_state = 2}, + [1195] = {.lex_state = 27, .external_lex_state = 2}, + [1196] = {.lex_state = 22, .external_lex_state = 2}, + [1197] = {.lex_state = 7, .external_lex_state = 2}, + [1198] = {.lex_state = 7, .external_lex_state = 2}, + [1199] = {.lex_state = 7, .external_lex_state = 2}, + [1200] = {.lex_state = 7, .external_lex_state = 2}, + [1201] = {.lex_state = 7, .external_lex_state = 2}, + [1202] = {.lex_state = 27, .external_lex_state = 2}, + [1203] = {.lex_state = 7, .external_lex_state = 2}, + [1204] = {.lex_state = 7, .external_lex_state = 2}, + [1205] = {.lex_state = 5, .external_lex_state = 2}, + [1206] = {.lex_state = 13, .external_lex_state = 2}, + [1207] = {.lex_state = 13, .external_lex_state = 2}, + [1208] = {.lex_state = 13, .external_lex_state = 2}, + [1209] = {.lex_state = 13, .external_lex_state = 2}, + [1210] = {.lex_state = 13, .external_lex_state = 2}, + [1211] = {.lex_state = 6, .external_lex_state = 2}, + [1212] = {.lex_state = 13, .external_lex_state = 2}, + [1213] = {.lex_state = 23, .external_lex_state = 2}, + [1214] = {.lex_state = 23, .external_lex_state = 2}, + [1215] = {.lex_state = 5, .external_lex_state = 2}, + [1216] = {.lex_state = 6, .external_lex_state = 2}, + [1217] = {.lex_state = 13, .external_lex_state = 2}, + [1218] = {.lex_state = 6, .external_lex_state = 2}, + [1219] = {.lex_state = 38, .external_lex_state = 2}, + [1220] = {.lex_state = 22, .external_lex_state = 2}, + [1221] = {.lex_state = 6, .external_lex_state = 2}, + [1222] = {.lex_state = 22, .external_lex_state = 2}, + [1223] = {.lex_state = 13, .external_lex_state = 2}, + [1224] = {.lex_state = 5, .external_lex_state = 2}, + [1225] = {.lex_state = 6, .external_lex_state = 2}, + [1226] = {.lex_state = 6, .external_lex_state = 2}, + [1227] = {.lex_state = 5, .external_lex_state = 2}, + [1228] = {.lex_state = 5, .external_lex_state = 2}, + [1229] = {.lex_state = 5, .external_lex_state = 2}, + [1230] = {.lex_state = 5, .external_lex_state = 2}, + [1231] = {.lex_state = 5, .external_lex_state = 2}, + [1232] = {.lex_state = 5, .external_lex_state = 2}, + [1233] = {.lex_state = 5, .external_lex_state = 2}, + [1234] = {.lex_state = 5, .external_lex_state = 2}, + [1235] = {.lex_state = 5, .external_lex_state = 2}, + [1236] = {.lex_state = 5, .external_lex_state = 2}, + [1237] = {.lex_state = 5, .external_lex_state = 2}, + [1238] = {.lex_state = 28, .external_lex_state = 2}, + [1239] = {.lex_state = 5, .external_lex_state = 2}, + [1240] = {.lex_state = 5, .external_lex_state = 2}, + [1241] = {.lex_state = 5, .external_lex_state = 2}, + [1242] = {.lex_state = 5, .external_lex_state = 2}, + [1243] = {.lex_state = 5, .external_lex_state = 2}, + [1244] = {.lex_state = 27, .external_lex_state = 2}, + [1245] = {.lex_state = 5, .external_lex_state = 2}, + [1246] = {.lex_state = 5, .external_lex_state = 2}, + [1247] = {.lex_state = 5, .external_lex_state = 2}, + [1248] = {.lex_state = 5, .external_lex_state = 2}, + [1249] = {.lex_state = 28, .external_lex_state = 2}, + [1250] = {.lex_state = 5, .external_lex_state = 2}, + [1251] = {.lex_state = 5, .external_lex_state = 2}, + [1252] = {.lex_state = 5, .external_lex_state = 2}, + [1253] = {.lex_state = 5, .external_lex_state = 2}, + [1254] = {.lex_state = 5, .external_lex_state = 2}, + [1255] = {.lex_state = 5, .external_lex_state = 2}, + [1256] = {.lex_state = 28, .external_lex_state = 2}, + [1257] = {.lex_state = 5, .external_lex_state = 2}, + [1258] = {.lex_state = 5, .external_lex_state = 2}, + [1259] = {.lex_state = 6, .external_lex_state = 2}, + [1260] = {.lex_state = 6, .external_lex_state = 2}, + [1261] = {.lex_state = 5, .external_lex_state = 2}, + [1262] = {.lex_state = 5, .external_lex_state = 2}, + [1263] = {.lex_state = 5, .external_lex_state = 2}, + [1264] = {.lex_state = 5, .external_lex_state = 2}, + [1265] = {.lex_state = 5, .external_lex_state = 2}, + [1266] = {.lex_state = 5, .external_lex_state = 2}, + [1267] = {.lex_state = 5, .external_lex_state = 2}, + [1268] = {.lex_state = 6, .external_lex_state = 2}, + [1269] = {.lex_state = 6, .external_lex_state = 2}, + [1270] = {.lex_state = 5, .external_lex_state = 2}, + [1271] = {.lex_state = 5, .external_lex_state = 2}, + [1272] = {.lex_state = 5, .external_lex_state = 2}, + [1273] = {.lex_state = 5, .external_lex_state = 2}, + [1274] = {.lex_state = 5, .external_lex_state = 2}, + [1275] = {.lex_state = 27, .external_lex_state = 2}, + [1276] = {.lex_state = 5, .external_lex_state = 2}, + [1277] = {.lex_state = 5, .external_lex_state = 2}, + [1278] = {.lex_state = 6, .external_lex_state = 2}, + [1279] = {.lex_state = 5, .external_lex_state = 2}, + [1280] = {.lex_state = 6, .external_lex_state = 2}, + [1281] = {.lex_state = 101, .external_lex_state = 2}, + [1282] = {.lex_state = 5, .external_lex_state = 2}, + [1283] = {.lex_state = 5, .external_lex_state = 2}, + [1284] = {.lex_state = 5, .external_lex_state = 2}, + [1285] = {.lex_state = 5, .external_lex_state = 2}, + [1286] = {.lex_state = 5, .external_lex_state = 2}, + [1287] = {.lex_state = 5, .external_lex_state = 2}, + [1288] = {.lex_state = 5, .external_lex_state = 2}, + [1289] = {.lex_state = 5, .external_lex_state = 2}, + [1290] = {.lex_state = 5, .external_lex_state = 2}, + [1291] = {.lex_state = 101, .external_lex_state = 2}, + [1292] = {.lex_state = 6, .external_lex_state = 2}, + [1293] = {.lex_state = 5, .external_lex_state = 2}, + [1294] = {.lex_state = 6, .external_lex_state = 2}, + [1295] = {.lex_state = 5, .external_lex_state = 2}, + [1296] = {.lex_state = 5, .external_lex_state = 2}, + [1297] = {.lex_state = 6, .external_lex_state = 2}, + [1298] = {.lex_state = 5, .external_lex_state = 2}, + [1299] = {.lex_state = 5, .external_lex_state = 2}, + [1300] = {.lex_state = 5, .external_lex_state = 2}, + [1301] = {.lex_state = 5, .external_lex_state = 2}, + [1302] = {.lex_state = 5, .external_lex_state = 2}, + [1303] = {.lex_state = 6, .external_lex_state = 2}, + [1304] = {.lex_state = 5, .external_lex_state = 2}, + [1305] = {.lex_state = 5, .external_lex_state = 2}, + [1306] = {.lex_state = 5, .external_lex_state = 2}, + [1307] = {.lex_state = 5, .external_lex_state = 2}, + [1308] = {.lex_state = 5, .external_lex_state = 2}, + [1309] = {.lex_state = 5, .external_lex_state = 2}, + [1310] = {.lex_state = 5, .external_lex_state = 2}, + [1311] = {.lex_state = 5, .external_lex_state = 2}, + [1312] = {.lex_state = 5, .external_lex_state = 2}, + [1313] = {.lex_state = 38, .external_lex_state = 2}, + [1314] = {.lex_state = 27, .external_lex_state = 2}, + [1315] = {.lex_state = 27, .external_lex_state = 2}, + [1316] = {.lex_state = 27, .external_lex_state = 2}, + [1317] = {.lex_state = 27, .external_lex_state = 2}, + [1318] = {.lex_state = 27, .external_lex_state = 2}, + [1319] = {.lex_state = 27, .external_lex_state = 2}, + [1320] = {.lex_state = 27, .external_lex_state = 2}, + [1321] = {.lex_state = 27, .external_lex_state = 2}, + [1322] = {.lex_state = 27, .external_lex_state = 2}, + [1323] = {.lex_state = 27, .external_lex_state = 2}, + [1324] = {.lex_state = 101, .external_lex_state = 2}, + [1325] = {.lex_state = 27, .external_lex_state = 2}, + [1326] = {.lex_state = 6, .external_lex_state = 2}, + [1327] = {.lex_state = 27, .external_lex_state = 2}, + [1328] = {.lex_state = 27, .external_lex_state = 2}, + [1329] = {.lex_state = 101, .external_lex_state = 2}, + [1330] = {.lex_state = 27, .external_lex_state = 2}, + [1331] = {.lex_state = 27, .external_lex_state = 2}, + [1332] = {.lex_state = 101, .external_lex_state = 2}, + [1333] = {.lex_state = 101, .external_lex_state = 2}, + [1334] = {.lex_state = 101, .external_lex_state = 2}, + [1335] = {.lex_state = 27, .external_lex_state = 2}, + [1336] = {.lex_state = 101, .external_lex_state = 2}, + [1337] = {.lex_state = 101, .external_lex_state = 2}, + [1338] = {.lex_state = 6, .external_lex_state = 2}, + [1339] = {.lex_state = 27, .external_lex_state = 2}, + [1340] = {.lex_state = 6, .external_lex_state = 2}, + [1341] = {.lex_state = 28, .external_lex_state = 2}, + [1342] = {.lex_state = 28, .external_lex_state = 2}, + [1343] = {.lex_state = 101, .external_lex_state = 2}, + [1344] = {.lex_state = 27, .external_lex_state = 2}, + [1345] = {.lex_state = 101, .external_lex_state = 2}, + [1346] = {.lex_state = 101, .external_lex_state = 2}, + [1347] = {.lex_state = 101, .external_lex_state = 2}, + [1348] = {.lex_state = 6, .external_lex_state = 2}, + [1349] = {.lex_state = 6, .external_lex_state = 2}, + [1350] = {.lex_state = 101, .external_lex_state = 2}, + [1351] = {.lex_state = 27, .external_lex_state = 2}, + [1352] = {.lex_state = 26, .external_lex_state = 2}, + [1353] = {.lex_state = 6, .external_lex_state = 2}, + [1354] = {.lex_state = 101, .external_lex_state = 2}, + [1355] = {.lex_state = 6, .external_lex_state = 2}, + [1356] = {.lex_state = 26, .external_lex_state = 2}, + [1357] = {.lex_state = 101, .external_lex_state = 2}, + [1358] = {.lex_state = 6, .external_lex_state = 2}, + [1359] = {.lex_state = 101, .external_lex_state = 2}, + [1360] = {.lex_state = 6, .external_lex_state = 2}, + [1361] = {.lex_state = 101, .external_lex_state = 2}, + [1362] = {.lex_state = 6, .external_lex_state = 2}, + [1363] = {.lex_state = 6, .external_lex_state = 2}, + [1364] = {.lex_state = 26, .external_lex_state = 2}, + [1365] = {.lex_state = 6, .external_lex_state = 2}, + [1366] = {.lex_state = 6, .external_lex_state = 2}, + [1367] = {.lex_state = 6, .external_lex_state = 2}, + [1368] = {.lex_state = 6, .external_lex_state = 2}, + [1369] = {.lex_state = 6, .external_lex_state = 2}, + [1370] = {.lex_state = 6, .external_lex_state = 2}, + [1371] = {.lex_state = 6, .external_lex_state = 2}, + [1372] = {.lex_state = 101, .external_lex_state = 2}, + [1373] = {.lex_state = 27, .external_lex_state = 2}, + [1374] = {.lex_state = 101, .external_lex_state = 2}, + [1375] = {.lex_state = 28, .external_lex_state = 2}, + [1376] = {.lex_state = 27, .external_lex_state = 2}, + [1377] = {.lex_state = 28, .external_lex_state = 2}, + [1378] = {.lex_state = 101, .external_lex_state = 2}, + [1379] = {.lex_state = 27, .external_lex_state = 2}, + [1380] = {.lex_state = 27, .external_lex_state = 2}, + [1381] = {.lex_state = 28, .external_lex_state = 2}, + [1382] = {.lex_state = 28, .external_lex_state = 2}, + [1383] = {.lex_state = 28, .external_lex_state = 2}, + [1384] = {.lex_state = 28, .external_lex_state = 2}, + [1385] = {.lex_state = 23, .external_lex_state = 2}, + [1386] = {.lex_state = 27, .external_lex_state = 2}, + [1387] = {.lex_state = 28, .external_lex_state = 2}, + [1388] = {.lex_state = 27, .external_lex_state = 2}, + [1389] = {.lex_state = 27, .external_lex_state = 2}, + [1390] = {.lex_state = 27, .external_lex_state = 2}, + [1391] = {.lex_state = 28, .external_lex_state = 2}, + [1392] = {.lex_state = 28, .external_lex_state = 2}, + [1393] = {.lex_state = 101, .external_lex_state = 2}, + [1394] = {.lex_state = 28, .external_lex_state = 2}, + [1395] = {.lex_state = 27, .external_lex_state = 2}, + [1396] = {.lex_state = 27, .external_lex_state = 2}, + [1397] = {.lex_state = 27, .external_lex_state = 2}, + [1398] = {.lex_state = 28, .external_lex_state = 2}, + [1399] = {.lex_state = 28, .external_lex_state = 2}, + [1400] = {.lex_state = 100, .external_lex_state = 2}, + [1401] = {.lex_state = 28, .external_lex_state = 2}, + [1402] = {.lex_state = 101, .external_lex_state = 2}, + [1403] = {.lex_state = 28, .external_lex_state = 2}, + [1404] = {.lex_state = 27, .external_lex_state = 2}, + [1405] = {.lex_state = 28, .external_lex_state = 2}, + [1406] = {.lex_state = 27, .external_lex_state = 2}, + [1407] = {.lex_state = 101, .external_lex_state = 2}, + [1408] = {.lex_state = 27, .external_lex_state = 2}, + [1409] = {.lex_state = 27, .external_lex_state = 2}, + [1410] = {.lex_state = 28, .external_lex_state = 2}, + [1411] = {.lex_state = 101, .external_lex_state = 2}, + [1412] = {.lex_state = 27, .external_lex_state = 2}, + [1413] = {.lex_state = 23, .external_lex_state = 2}, + [1414] = {.lex_state = 28, .external_lex_state = 2}, + [1415] = {.lex_state = 101, .external_lex_state = 2}, + [1416] = {.lex_state = 27, .external_lex_state = 2}, + [1417] = {.lex_state = 100, .external_lex_state = 2}, + [1418] = {.lex_state = 27, .external_lex_state = 2}, + [1419] = {.lex_state = 27, .external_lex_state = 2}, + [1420] = {.lex_state = 27, .external_lex_state = 2}, + [1421] = {.lex_state = 27, .external_lex_state = 2}, + [1422] = {.lex_state = 27, .external_lex_state = 2}, + [1423] = {.lex_state = 27, .external_lex_state = 2}, + [1424] = {.lex_state = 28, .external_lex_state = 2}, + [1425] = {.lex_state = 27, .external_lex_state = 2}, + [1426] = {.lex_state = 27, .external_lex_state = 2}, + [1427] = {.lex_state = 27, .external_lex_state = 2}, + [1428] = {.lex_state = 27, .external_lex_state = 2}, + [1429] = {.lex_state = 28, .external_lex_state = 2}, + [1430] = {.lex_state = 27, .external_lex_state = 2}, + [1431] = {.lex_state = 28, .external_lex_state = 2}, + [1432] = {.lex_state = 27, .external_lex_state = 2}, + [1433] = {.lex_state = 25, .external_lex_state = 2}, + [1434] = {.lex_state = 25, .external_lex_state = 2}, + [1435] = {.lex_state = 26, .external_lex_state = 2}, + [1436] = {.lex_state = 25, .external_lex_state = 2}, + [1437] = {.lex_state = 28, .external_lex_state = 2}, + [1438] = {.lex_state = 27, .external_lex_state = 2}, + [1439] = {.lex_state = 27, .external_lex_state = 2}, + [1440] = {.lex_state = 27, .external_lex_state = 2}, + [1441] = {.lex_state = 27, .external_lex_state = 2}, + [1442] = {.lex_state = 27, .external_lex_state = 2}, + [1443] = {.lex_state = 27, .external_lex_state = 2}, + [1444] = {.lex_state = 27, .external_lex_state = 2}, + [1445] = {.lex_state = 27, .external_lex_state = 2}, + [1446] = {.lex_state = 27, .external_lex_state = 2}, + [1447] = {.lex_state = 27, .external_lex_state = 2}, + [1448] = {.lex_state = 27, .external_lex_state = 2}, + [1449] = {.lex_state = 27, .external_lex_state = 2}, + [1450] = {.lex_state = 27, .external_lex_state = 2}, + [1451] = {.lex_state = 27, .external_lex_state = 2}, + [1452] = {.lex_state = 26, .external_lex_state = 2}, + [1453] = {.lex_state = 27, .external_lex_state = 2}, + [1454] = {.lex_state = 27, .external_lex_state = 2}, + [1455] = {.lex_state = 27, .external_lex_state = 2}, + [1456] = {.lex_state = 27, .external_lex_state = 2}, + [1457] = {.lex_state = 27, .external_lex_state = 2}, + [1458] = {.lex_state = 27, .external_lex_state = 2}, + [1459] = {.lex_state = 27, .external_lex_state = 2}, + [1460] = {.lex_state = 27, .external_lex_state = 2}, + [1461] = {.lex_state = 27, .external_lex_state = 2}, + [1462] = {.lex_state = 23, .external_lex_state = 2}, + [1463] = {.lex_state = 28, .external_lex_state = 2}, + [1464] = {.lex_state = 27, .external_lex_state = 2}, + [1465] = {.lex_state = 28, .external_lex_state = 2}, + [1466] = {.lex_state = 28, .external_lex_state = 2}, + [1467] = {.lex_state = 28, .external_lex_state = 2}, + [1468] = {.lex_state = 28, .external_lex_state = 2}, + [1469] = {.lex_state = 26, .external_lex_state = 2}, + [1470] = {.lex_state = 28, .external_lex_state = 2}, + [1471] = {.lex_state = 28, .external_lex_state = 2}, + [1472] = {.lex_state = 26, .external_lex_state = 2}, + [1473] = {.lex_state = 27, .external_lex_state = 2}, + [1474] = {.lex_state = 28, .external_lex_state = 2}, + [1475] = {.lex_state = 28, .external_lex_state = 2}, + [1476] = {.lex_state = 26, .external_lex_state = 2}, + [1477] = {.lex_state = 28, .external_lex_state = 2}, + [1478] = {.lex_state = 100, .external_lex_state = 2}, + [1479] = {.lex_state = 19, .external_lex_state = 2}, + [1480] = {.lex_state = 27, .external_lex_state = 2}, + [1481] = {.lex_state = 38, .external_lex_state = 2}, + [1482] = {.lex_state = 27, .external_lex_state = 2}, + [1483] = {.lex_state = 26, .external_lex_state = 2}, + [1484] = {.lex_state = 100, .external_lex_state = 2}, + [1485] = {.lex_state = 26, .external_lex_state = 2}, + [1486] = {.lex_state = 27, .external_lex_state = 2}, + [1487] = {.lex_state = 19, .external_lex_state = 2}, + [1488] = {.lex_state = 27, .external_lex_state = 2}, + [1489] = {.lex_state = 26, .external_lex_state = 2}, + [1490] = {.lex_state = 26, .external_lex_state = 2}, + [1491] = {.lex_state = 100, .external_lex_state = 2}, + [1492] = {.lex_state = 28, .external_lex_state = 2}, + [1493] = {.lex_state = 26, .external_lex_state = 2}, + [1494] = {.lex_state = 26, .external_lex_state = 2}, + [1495] = {.lex_state = 27, .external_lex_state = 2}, + [1496] = {.lex_state = 27, .external_lex_state = 2}, + [1497] = {.lex_state = 26, .external_lex_state = 2}, + [1498] = {.lex_state = 26, .external_lex_state = 2}, + [1499] = {.lex_state = 28, .external_lex_state = 2}, + [1500] = {.lex_state = 27, .external_lex_state = 2}, + [1501] = {.lex_state = 26, .external_lex_state = 2}, + [1502] = {.lex_state = 38, .external_lex_state = 2}, + [1503] = {.lex_state = 27, .external_lex_state = 2}, + [1504] = {.lex_state = 28, .external_lex_state = 2}, + [1505] = {.lex_state = 26, .external_lex_state = 2}, + [1506] = {.lex_state = 26, .external_lex_state = 2}, + [1507] = {.lex_state = 26, .external_lex_state = 2}, + [1508] = {.lex_state = 28, .external_lex_state = 2}, + [1509] = {.lex_state = 26, .external_lex_state = 2}, + [1510] = {.lex_state = 28, .external_lex_state = 2}, + [1511] = {.lex_state = 26, .external_lex_state = 2}, + [1512] = {.lex_state = 100, .external_lex_state = 2}, + [1513] = {.lex_state = 28, .external_lex_state = 2}, + [1514] = {.lex_state = 28, .external_lex_state = 2}, + [1515] = {.lex_state = 28, .external_lex_state = 2}, + [1516] = {.lex_state = 28, .external_lex_state = 2}, + [1517] = {.lex_state = 28, .external_lex_state = 2}, + [1518] = {.lex_state = 28, .external_lex_state = 2}, + [1519] = {.lex_state = 28, .external_lex_state = 2}, + [1520] = {.lex_state = 28, .external_lex_state = 2}, + [1521] = {.lex_state = 28, .external_lex_state = 2}, + [1522] = {.lex_state = 28, .external_lex_state = 2}, + [1523] = {.lex_state = 19, .external_lex_state = 2}, + [1524] = {.lex_state = 26, .external_lex_state = 2}, + [1525] = {.lex_state = 28, .external_lex_state = 2}, + [1526] = {.lex_state = 38, .external_lex_state = 2}, + [1527] = {.lex_state = 28, .external_lex_state = 2}, + [1528] = {.lex_state = 28, .external_lex_state = 2}, + [1529] = {.lex_state = 28, .external_lex_state = 2}, + [1530] = {.lex_state = 38, .external_lex_state = 2}, + [1531] = {.lex_state = 28, .external_lex_state = 2}, + [1532] = {.lex_state = 28, .external_lex_state = 2}, + [1533] = {.lex_state = 28, .external_lex_state = 2}, + [1534] = {.lex_state = 28, .external_lex_state = 2}, + [1535] = {.lex_state = 38, .external_lex_state = 2}, + [1536] = {.lex_state = 19, .external_lex_state = 2}, + [1537] = {.lex_state = 100, .external_lex_state = 2}, + [1538] = {.lex_state = 6, .external_lex_state = 2}, + [1539] = {.lex_state = 6, .external_lex_state = 2}, + [1540] = {.lex_state = 28, .external_lex_state = 2}, + [1541] = {.lex_state = 28, .external_lex_state = 2}, + [1542] = {.lex_state = 28, .external_lex_state = 2}, + [1543] = {.lex_state = 28, .external_lex_state = 2}, + [1544] = {.lex_state = 28, .external_lex_state = 2}, + [1545] = {.lex_state = 28, .external_lex_state = 2}, + [1546] = {.lex_state = 28, .external_lex_state = 2}, + [1547] = {.lex_state = 28, .external_lex_state = 2}, + [1548] = {.lex_state = 26, .external_lex_state = 2}, + [1549] = {.lex_state = 26, .external_lex_state = 2}, + [1550] = {.lex_state = 28, .external_lex_state = 2}, + [1551] = {.lex_state = 28, .external_lex_state = 2}, + [1552] = {.lex_state = 28, .external_lex_state = 2}, + [1553] = {.lex_state = 28, .external_lex_state = 2}, + [1554] = {.lex_state = 28, .external_lex_state = 2}, + [1555] = {.lex_state = 28, .external_lex_state = 2}, + [1556] = {.lex_state = 28, .external_lex_state = 2}, + [1557] = {.lex_state = 28, .external_lex_state = 2}, + [1558] = {.lex_state = 28, .external_lex_state = 2}, + [1559] = {.lex_state = 28, .external_lex_state = 2}, + [1560] = {.lex_state = 26, .external_lex_state = 2}, + [1561] = {.lex_state = 19, .external_lex_state = 2}, + [1562] = {.lex_state = 19, .external_lex_state = 2}, + [1563] = {.lex_state = 101, .external_lex_state = 2}, + [1564] = {.lex_state = 26, .external_lex_state = 2}, + [1565] = {.lex_state = 38, .external_lex_state = 2}, + [1566] = {.lex_state = 38, .external_lex_state = 2}, + [1567] = {.lex_state = 6, .external_lex_state = 2}, + [1568] = {.lex_state = 6, .external_lex_state = 2}, + [1569] = {.lex_state = 6, .external_lex_state = 2}, + [1570] = {.lex_state = 100, .external_lex_state = 2}, + [1571] = {.lex_state = 100, .external_lex_state = 2}, + [1572] = {.lex_state = 100, .external_lex_state = 2}, + [1573] = {.lex_state = 6, .external_lex_state = 2}, + [1574] = {.lex_state = 6, .external_lex_state = 2}, + [1575] = {.lex_state = 100, .external_lex_state = 2}, + [1576] = {.lex_state = 6, .external_lex_state = 2}, + [1577] = {.lex_state = 38, .external_lex_state = 2}, + [1578] = {.lex_state = 26, .external_lex_state = 2}, + [1579] = {.lex_state = 28, .external_lex_state = 2}, + [1580] = {.lex_state = 100, .external_lex_state = 2}, + [1581] = {.lex_state = 100, .external_lex_state = 2}, + [1582] = {.lex_state = 28, .external_lex_state = 2}, + [1583] = {.lex_state = 28, .external_lex_state = 2}, + [1584] = {.lex_state = 28, .external_lex_state = 2}, + [1585] = {.lex_state = 100, .external_lex_state = 2}, + [1586] = {.lex_state = 38, .external_lex_state = 2}, + [1587] = {.lex_state = 26, .external_lex_state = 2}, + [1588] = {.lex_state = 100, .external_lex_state = 2}, + [1589] = {.lex_state = 38, .external_lex_state = 2}, + [1590] = {.lex_state = 100, .external_lex_state = 2}, + [1591] = {.lex_state = 26, .external_lex_state = 2}, + [1592] = {.lex_state = 23, .external_lex_state = 2}, + [1593] = {.lex_state = 100, .external_lex_state = 2}, + [1594] = {.lex_state = 26, .external_lex_state = 2}, + [1595] = {.lex_state = 100, .external_lex_state = 2}, + [1596] = {.lex_state = 26, .external_lex_state = 2}, + [1597] = {.lex_state = 26, .external_lex_state = 2}, + [1598] = {.lex_state = 26, .external_lex_state = 2}, + [1599] = {.lex_state = 26, .external_lex_state = 2}, + [1600] = {.lex_state = 26, .external_lex_state = 2}, + [1601] = {.lex_state = 26, .external_lex_state = 2}, + [1602] = {.lex_state = 28, .external_lex_state = 2}, + [1603] = {.lex_state = 26, .external_lex_state = 2}, + [1604] = {.lex_state = 28, .external_lex_state = 2}, + [1605] = {.lex_state = 38, .external_lex_state = 2}, + [1606] = {.lex_state = 23, .external_lex_state = 2}, + [1607] = {.lex_state = 38, .external_lex_state = 2}, + [1608] = {.lex_state = 100, .external_lex_state = 2}, + [1609] = {.lex_state = 28, .external_lex_state = 2}, + [1610] = {.lex_state = 28, .external_lex_state = 2}, + [1611] = {.lex_state = 28, .external_lex_state = 2}, + [1612] = {.lex_state = 100, .external_lex_state = 2}, + [1613] = {.lex_state = 26, .external_lex_state = 2}, + [1614] = {.lex_state = 38, .external_lex_state = 2}, + [1615] = {.lex_state = 28, .external_lex_state = 2}, + [1616] = {.lex_state = 100, .external_lex_state = 2}, + [1617] = {.lex_state = 100, .external_lex_state = 2}, + [1618] = {.lex_state = 100, .external_lex_state = 2}, + [1619] = {.lex_state = 26, .external_lex_state = 2}, + [1620] = {.lex_state = 26, .external_lex_state = 2}, + [1621] = {.lex_state = 100, .external_lex_state = 2}, + [1622] = {.lex_state = 100, .external_lex_state = 2}, + [1623] = {.lex_state = 38, .external_lex_state = 2}, + [1624] = {.lex_state = 26, .external_lex_state = 2}, + [1625] = {.lex_state = 6, .external_lex_state = 2}, + [1626] = {.lex_state = 6, .external_lex_state = 2}, + [1627] = {.lex_state = 26, .external_lex_state = 2}, + [1628] = {.lex_state = 26, .external_lex_state = 2}, + [1629] = {.lex_state = 26, .external_lex_state = 2}, + [1630] = {.lex_state = 101, .external_lex_state = 2}, + [1631] = {.lex_state = 26, .external_lex_state = 2}, + [1632] = {.lex_state = 26, .external_lex_state = 2}, + [1633] = {.lex_state = 26, .external_lex_state = 2}, + [1634] = {.lex_state = 26, .external_lex_state = 2}, + [1635] = {.lex_state = 26, .external_lex_state = 2}, + [1636] = {.lex_state = 26, .external_lex_state = 2}, + [1637] = {.lex_state = 38, .external_lex_state = 2}, + [1638] = {.lex_state = 26, .external_lex_state = 2}, + [1639] = {.lex_state = 26, .external_lex_state = 2}, + [1640] = {.lex_state = 26, .external_lex_state = 2}, + [1641] = {.lex_state = 38, .external_lex_state = 2}, + [1642] = {.lex_state = 38, .external_lex_state = 2}, + [1643] = {.lex_state = 26, .external_lex_state = 2}, + [1644] = {.lex_state = 38, .external_lex_state = 2}, + [1645] = {.lex_state = 38, .external_lex_state = 2}, + [1646] = {.lex_state = 6, .external_lex_state = 2}, + [1647] = {.lex_state = 26, .external_lex_state = 2}, + [1648] = {.lex_state = 38, .external_lex_state = 2}, + [1649] = {.lex_state = 38, .external_lex_state = 2}, + [1650] = {.lex_state = 26, .external_lex_state = 2}, + [1651] = {.lex_state = 26, .external_lex_state = 2}, + [1652] = {.lex_state = 26, .external_lex_state = 2}, + [1653] = {.lex_state = 6, .external_lex_state = 2}, + [1654] = {.lex_state = 6, .external_lex_state = 2}, + [1655] = {.lex_state = 6, .external_lex_state = 2}, + [1656] = {.lex_state = 6, .external_lex_state = 2}, + [1657] = {.lex_state = 26, .external_lex_state = 2}, + [1658] = {.lex_state = 26, .external_lex_state = 2}, + [1659] = {.lex_state = 26, .external_lex_state = 2}, + [1660] = {.lex_state = 26, .external_lex_state = 2}, + [1661] = {.lex_state = 38, .external_lex_state = 2}, + [1662] = {.lex_state = 38, .external_lex_state = 2}, + [1663] = {.lex_state = 26, .external_lex_state = 2}, + [1664] = {.lex_state = 26, .external_lex_state = 2}, + [1665] = {.lex_state = 26, .external_lex_state = 2}, + [1666] = {.lex_state = 26, .external_lex_state = 2}, + [1667] = {.lex_state = 38, .external_lex_state = 2}, + [1668] = {.lex_state = 6, .external_lex_state = 2}, + [1669] = {.lex_state = 26, .external_lex_state = 2}, + [1670] = {.lex_state = 26, .external_lex_state = 2}, + [1671] = {.lex_state = 26, .external_lex_state = 2}, + [1672] = {.lex_state = 26, .external_lex_state = 2}, + [1673] = {.lex_state = 26, .external_lex_state = 2}, + [1674] = {.lex_state = 26, .external_lex_state = 2}, + [1675] = {.lex_state = 26, .external_lex_state = 2}, + [1676] = {.lex_state = 26, .external_lex_state = 2}, + [1677] = {.lex_state = 26, .external_lex_state = 2}, + [1678] = {.lex_state = 26, .external_lex_state = 2}, + [1679] = {.lex_state = 26, .external_lex_state = 2}, + [1680] = {.lex_state = 26, .external_lex_state = 2}, + [1681] = {.lex_state = 101, .external_lex_state = 2}, + [1682] = {.lex_state = 38, .external_lex_state = 2}, + [1683] = {.lex_state = 101, .external_lex_state = 2}, + [1684] = {.lex_state = 101, .external_lex_state = 2}, + [1685] = {.lex_state = 38, .external_lex_state = 2}, + [1686] = {.lex_state = 38, .external_lex_state = 2}, + [1687] = {.lex_state = 101, .external_lex_state = 2}, + [1688] = {.lex_state = 100, .external_lex_state = 2}, + [1689] = {.lex_state = 38, .external_lex_state = 2}, + [1690] = {.lex_state = 101, .external_lex_state = 2}, + [1691] = {.lex_state = 38, .external_lex_state = 2}, + [1692] = {.lex_state = 101, .external_lex_state = 2}, + [1693] = {.lex_state = 101, .external_lex_state = 2}, + [1694] = {.lex_state = 38, .external_lex_state = 2}, + [1695] = {.lex_state = 26, .external_lex_state = 2}, + [1696] = {.lex_state = 26, .external_lex_state = 2}, + [1697] = {.lex_state = 101, .external_lex_state = 2}, + [1698] = {.lex_state = 26, .external_lex_state = 2}, + [1699] = {.lex_state = 38, .external_lex_state = 2}, + [1700] = {.lex_state = 38, .external_lex_state = 2}, + [1701] = {.lex_state = 38, .external_lex_state = 2}, + [1702] = {.lex_state = 38, .external_lex_state = 2}, + [1703] = {.lex_state = 101, .external_lex_state = 2}, + [1704] = {.lex_state = 101, .external_lex_state = 2}, + [1705] = {.lex_state = 100, .external_lex_state = 2}, + [1706] = {.lex_state = 101, .external_lex_state = 2}, + [1707] = {.lex_state = 101, .external_lex_state = 2}, + [1708] = {.lex_state = 38, .external_lex_state = 2}, + [1709] = {.lex_state = 26, .external_lex_state = 2}, + [1710] = {.lex_state = 38, .external_lex_state = 2}, + [1711] = {.lex_state = 26, .external_lex_state = 2}, + [1712] = {.lex_state = 26, .external_lex_state = 2}, + [1713] = {.lex_state = 101, .external_lex_state = 2}, + [1714] = {.lex_state = 101, .external_lex_state = 2}, + [1715] = {.lex_state = 101, .external_lex_state = 2}, + [1716] = {.lex_state = 101, .external_lex_state = 2}, + [1717] = {.lex_state = 38, .external_lex_state = 2}, + [1718] = {.lex_state = 101, .external_lex_state = 2}, + [1719] = {.lex_state = 101, .external_lex_state = 2}, + [1720] = {.lex_state = 38, .external_lex_state = 2}, + [1721] = {.lex_state = 38, .external_lex_state = 2}, + [1722] = {.lex_state = 100, .external_lex_state = 2}, + [1723] = {.lex_state = 38, .external_lex_state = 2}, + [1724] = {.lex_state = 26, .external_lex_state = 2}, + [1725] = {.lex_state = 38, .external_lex_state = 2}, + [1726] = {.lex_state = 26, .external_lex_state = 2}, + [1727] = {.lex_state = 38, .external_lex_state = 2}, + [1728] = {.lex_state = 100, .external_lex_state = 2}, + [1729] = {.lex_state = 101, .external_lex_state = 2}, + [1730] = {.lex_state = 102, .external_lex_state = 2}, + [1731] = {.lex_state = 100, .external_lex_state = 2}, + [1732] = {.lex_state = 100, .external_lex_state = 2}, + [1733] = {.lex_state = 0, .external_lex_state = 2}, + [1734] = {.lex_state = 100, .external_lex_state = 2}, + [1735] = {.lex_state = 100, .external_lex_state = 2}, + [1736] = {.lex_state = 102, .external_lex_state = 2}, + [1737] = {.lex_state = 101, .external_lex_state = 2}, + [1738] = {.lex_state = 101, .external_lex_state = 2}, + [1739] = {.lex_state = 101, .external_lex_state = 2}, + [1740] = {.lex_state = 101, .external_lex_state = 2}, + [1741] = {.lex_state = 101, .external_lex_state = 2}, + [1742] = {.lex_state = 101, .external_lex_state = 2}, + [1743] = {.lex_state = 101, .external_lex_state = 2}, + [1744] = {.lex_state = 101, .external_lex_state = 2}, + [1745] = {.lex_state = 101, .external_lex_state = 2}, + [1746] = {.lex_state = 101, .external_lex_state = 2}, + [1747] = {.lex_state = 101, .external_lex_state = 2}, + [1748] = {.lex_state = 101, .external_lex_state = 2}, + [1749] = {.lex_state = 101, .external_lex_state = 2}, + [1750] = {.lex_state = 101, .external_lex_state = 2}, + [1751] = {.lex_state = 101, .external_lex_state = 2}, + [1752] = {.lex_state = 101, .external_lex_state = 2}, + [1753] = {.lex_state = 101, .external_lex_state = 2}, + [1754] = {.lex_state = 101, .external_lex_state = 2}, + [1755] = {.lex_state = 101, .external_lex_state = 2}, + [1756] = {.lex_state = 101, .external_lex_state = 2}, + [1757] = {.lex_state = 101, .external_lex_state = 2}, + [1758] = {.lex_state = 101, .external_lex_state = 2}, + [1759] = {.lex_state = 101, .external_lex_state = 2}, + [1760] = {.lex_state = 101, .external_lex_state = 2}, + [1761] = {.lex_state = 101, .external_lex_state = 2}, + [1762] = {.lex_state = 101, .external_lex_state = 2}, + [1763] = {.lex_state = 101, .external_lex_state = 2}, + [1764] = {.lex_state = 101, .external_lex_state = 2}, + [1765] = {.lex_state = 101, .external_lex_state = 2}, + [1766] = {.lex_state = 101, .external_lex_state = 2}, + [1767] = {.lex_state = 101, .external_lex_state = 2}, + [1768] = {.lex_state = 101, .external_lex_state = 2}, + [1769] = {.lex_state = 101, .external_lex_state = 2}, + [1770] = {.lex_state = 101, .external_lex_state = 2}, + [1771] = {.lex_state = 101, .external_lex_state = 2}, + [1772] = {.lex_state = 101, .external_lex_state = 2}, + [1773] = {.lex_state = 101, .external_lex_state = 2}, + [1774] = {.lex_state = 101, .external_lex_state = 2}, + [1775] = {.lex_state = 101, .external_lex_state = 2}, + [1776] = {.lex_state = 101, .external_lex_state = 2}, + [1777] = {.lex_state = 101, .external_lex_state = 2}, + [1778] = {.lex_state = 101, .external_lex_state = 2}, + [1779] = {.lex_state = 101, .external_lex_state = 2}, + [1780] = {.lex_state = 101, .external_lex_state = 2}, + [1781] = {.lex_state = 101, .external_lex_state = 2}, + [1782] = {.lex_state = 101, .external_lex_state = 2}, + [1783] = {.lex_state = 101, .external_lex_state = 2}, + [1784] = {.lex_state = 101, .external_lex_state = 2}, + [1785] = {.lex_state = 101, .external_lex_state = 2}, + [1786] = {.lex_state = 101, .external_lex_state = 2}, + [1787] = {.lex_state = 101, .external_lex_state = 2}, + [1788] = {.lex_state = 101, .external_lex_state = 2}, + [1789] = {.lex_state = 101, .external_lex_state = 2}, + [1790] = {.lex_state = 101, .external_lex_state = 2}, + [1791] = {.lex_state = 101, .external_lex_state = 2}, + [1792] = {.lex_state = 101, .external_lex_state = 2}, + [1793] = {.lex_state = 101, .external_lex_state = 2}, + [1794] = {.lex_state = 101, .external_lex_state = 2}, + [1795] = {.lex_state = 101, .external_lex_state = 2}, + [1796] = {.lex_state = 101, .external_lex_state = 2}, + [1797] = {.lex_state = 101, .external_lex_state = 2}, + [1798] = {.lex_state = 101, .external_lex_state = 2}, + [1799] = {.lex_state = 101, .external_lex_state = 2}, + [1800] = {.lex_state = 101, .external_lex_state = 2}, + [1801] = {.lex_state = 101, .external_lex_state = 2}, + [1802] = {.lex_state = 101, .external_lex_state = 2}, + [1803] = {.lex_state = 101, .external_lex_state = 2}, + [1804] = {.lex_state = 101, .external_lex_state = 2}, + [1805] = {.lex_state = 101, .external_lex_state = 2}, + [1806] = {.lex_state = 101, .external_lex_state = 2}, + [1807] = {.lex_state = 101, .external_lex_state = 2}, + [1808] = {.lex_state = 101, .external_lex_state = 2}, + [1809] = {.lex_state = 101, .external_lex_state = 2}, + [1810] = {.lex_state = 101, .external_lex_state = 2}, + [1811] = {.lex_state = 101, .external_lex_state = 2}, + [1812] = {.lex_state = 101, .external_lex_state = 2}, + [1813] = {.lex_state = 101, .external_lex_state = 2}, + [1814] = {.lex_state = 101, .external_lex_state = 2}, + [1815] = {.lex_state = 101, .external_lex_state = 2}, + [1816] = {.lex_state = 101, .external_lex_state = 2}, + [1817] = {.lex_state = 101, .external_lex_state = 2}, + [1818] = {.lex_state = 101, .external_lex_state = 2}, + [1819] = {.lex_state = 101, .external_lex_state = 2}, + [1820] = {.lex_state = 101, .external_lex_state = 2}, + [1821] = {.lex_state = 101, .external_lex_state = 2}, + [1822] = {.lex_state = 101, .external_lex_state = 2}, + [1823] = {.lex_state = 101, .external_lex_state = 2}, + [1824] = {.lex_state = 101, .external_lex_state = 2}, + [1825] = {.lex_state = 101, .external_lex_state = 2}, + [1826] = {.lex_state = 101, .external_lex_state = 2}, + [1827] = {.lex_state = 101, .external_lex_state = 2}, + [1828] = {.lex_state = 101, .external_lex_state = 2}, + [1829] = {.lex_state = 101, .external_lex_state = 2}, + [1830] = {.lex_state = 101, .external_lex_state = 2}, + [1831] = {.lex_state = 101, .external_lex_state = 2}, + [1832] = {.lex_state = 101, .external_lex_state = 2}, + [1833] = {.lex_state = 101, .external_lex_state = 2}, + [1834] = {.lex_state = 19, .external_lex_state = 2}, + [1835] = {.lex_state = 19, .external_lex_state = 2}, + [1836] = {.lex_state = 19, .external_lex_state = 2}, + [1837] = {.lex_state = 19, .external_lex_state = 2}, + [1838] = {.lex_state = 101, .external_lex_state = 2}, + [1839] = {.lex_state = 19, .external_lex_state = 2}, + [1840] = {.lex_state = 19, .external_lex_state = 2}, + [1841] = {.lex_state = 19, .external_lex_state = 2}, + [1842] = {.lex_state = 19, .external_lex_state = 2}, + [1843] = {.lex_state = 19, .external_lex_state = 2}, + [1844] = {.lex_state = 19, .external_lex_state = 2}, + [1845] = {.lex_state = 19, .external_lex_state = 2}, + [1846] = {.lex_state = 19, .external_lex_state = 2}, + [1847] = {.lex_state = 0, .external_lex_state = 2}, + [1848] = {.lex_state = 101, .external_lex_state = 2}, + [1849] = {.lex_state = 101, .external_lex_state = 2}, + [1850] = {.lex_state = 101, .external_lex_state = 2}, + [1851] = {.lex_state = 101, .external_lex_state = 2}, + [1852] = {.lex_state = 101, .external_lex_state = 2}, + [1853] = {.lex_state = 101, .external_lex_state = 2}, + [1854] = {.lex_state = 19, .external_lex_state = 2}, + [1855] = {.lex_state = 101, .external_lex_state = 2}, + [1856] = {.lex_state = 101, .external_lex_state = 2}, + [1857] = {.lex_state = 101, .external_lex_state = 2}, + [1858] = {.lex_state = 19, .external_lex_state = 2}, + [1859] = {.lex_state = 101, .external_lex_state = 2}, + [1860] = {.lex_state = 101, .external_lex_state = 2}, + [1861] = {.lex_state = 101, .external_lex_state = 2}, + [1862] = {.lex_state = 19, .external_lex_state = 2}, + [1863] = {.lex_state = 19, .external_lex_state = 2}, + [1864] = {.lex_state = 0, .external_lex_state = 2}, + [1865] = {.lex_state = 101, .external_lex_state = 2}, + [1866] = {.lex_state = 0, .external_lex_state = 2}, + [1867] = {.lex_state = 101, .external_lex_state = 2}, + [1868] = {.lex_state = 101, .external_lex_state = 2}, + [1869] = {.lex_state = 101, .external_lex_state = 2}, + [1870] = {.lex_state = 101, .external_lex_state = 2}, + [1871] = {.lex_state = 101, .external_lex_state = 2}, + [1872] = {.lex_state = 101, .external_lex_state = 2}, + [1873] = {.lex_state = 101, .external_lex_state = 2}, + [1874] = {.lex_state = 101, .external_lex_state = 2}, + [1875] = {.lex_state = 101, .external_lex_state = 2}, + [1876] = {.lex_state = 101, .external_lex_state = 2}, + [1877] = {.lex_state = 101, .external_lex_state = 2}, + [1878] = {.lex_state = 101, .external_lex_state = 2}, + [1879] = {.lex_state = 101, .external_lex_state = 2}, + [1880] = {.lex_state = 101, .external_lex_state = 2}, + [1881] = {.lex_state = 101, .external_lex_state = 2}, + [1882] = {.lex_state = 101, .external_lex_state = 2}, + [1883] = {.lex_state = 101, .external_lex_state = 2}, + [1884] = {.lex_state = 101, .external_lex_state = 2}, + [1885] = {.lex_state = 101, .external_lex_state = 2}, + [1886] = {.lex_state = 101, .external_lex_state = 2}, + [1887] = {.lex_state = 101, .external_lex_state = 2}, + [1888] = {.lex_state = 101, .external_lex_state = 2}, + [1889] = {.lex_state = 101, .external_lex_state = 2}, + [1890] = {.lex_state = 101, .external_lex_state = 2}, + [1891] = {.lex_state = 101, .external_lex_state = 2}, + [1892] = {.lex_state = 101, .external_lex_state = 2}, + [1893] = {.lex_state = 101, .external_lex_state = 2}, + [1894] = {.lex_state = 101, .external_lex_state = 2}, + [1895] = {.lex_state = 101, .external_lex_state = 2}, + [1896] = {.lex_state = 101, .external_lex_state = 2}, + [1897] = {.lex_state = 19, .external_lex_state = 2}, + [1898] = {.lex_state = 101, .external_lex_state = 2}, + [1899] = {.lex_state = 101, .external_lex_state = 2}, + [1900] = {.lex_state = 101, .external_lex_state = 2}, + [1901] = {.lex_state = 101, .external_lex_state = 2}, + [1902] = {.lex_state = 101, .external_lex_state = 2}, + [1903] = {.lex_state = 101, .external_lex_state = 2}, + [1904] = {.lex_state = 101, .external_lex_state = 2}, + [1905] = {.lex_state = 101, .external_lex_state = 2}, + [1906] = {.lex_state = 101, .external_lex_state = 2}, + [1907] = {.lex_state = 101, .external_lex_state = 2}, + [1908] = {.lex_state = 101, .external_lex_state = 2}, + [1909] = {.lex_state = 38, .external_lex_state = 2}, + [1910] = {.lex_state = 101, .external_lex_state = 2}, + [1911] = {.lex_state = 101, .external_lex_state = 2}, + [1912] = {.lex_state = 0, .external_lex_state = 2}, + [1913] = {.lex_state = 101, .external_lex_state = 2}, + [1914] = {.lex_state = 101, .external_lex_state = 2}, + [1915] = {.lex_state = 101, .external_lex_state = 2}, + [1916] = {.lex_state = 19, .external_lex_state = 2}, + [1917] = {.lex_state = 0, .external_lex_state = 2}, + [1918] = {.lex_state = 0, .external_lex_state = 2}, + [1919] = {.lex_state = 101, .external_lex_state = 2}, + [1920] = {.lex_state = 101, .external_lex_state = 2}, + [1921] = {.lex_state = 101, .external_lex_state = 2}, + [1922] = {.lex_state = 101, .external_lex_state = 2}, + [1923] = {.lex_state = 0, .external_lex_state = 2}, + [1924] = {.lex_state = 101, .external_lex_state = 2}, + [1925] = {.lex_state = 101, .external_lex_state = 2}, + [1926] = {.lex_state = 101, .external_lex_state = 2}, + [1927] = {.lex_state = 101, .external_lex_state = 2}, + [1928] = {.lex_state = 101, .external_lex_state = 2}, + [1929] = {.lex_state = 101, .external_lex_state = 2}, + [1930] = {.lex_state = 101, .external_lex_state = 2}, + [1931] = {.lex_state = 101, .external_lex_state = 2}, + [1932] = {.lex_state = 101, .external_lex_state = 2}, + [1933] = {.lex_state = 101, .external_lex_state = 2}, + [1934] = {.lex_state = 101, .external_lex_state = 2}, + [1935] = {.lex_state = 101, .external_lex_state = 2}, + [1936] = {.lex_state = 24, .external_lex_state = 2}, + [1937] = {.lex_state = 101, .external_lex_state = 2}, + [1938] = {.lex_state = 101, .external_lex_state = 2}, + [1939] = {.lex_state = 101, .external_lex_state = 2}, + [1940] = {.lex_state = 100, .external_lex_state = 2}, + [1941] = {.lex_state = 101, .external_lex_state = 2}, + [1942] = {.lex_state = 100, .external_lex_state = 2}, + [1943] = {.lex_state = 101, .external_lex_state = 2}, + [1944] = {.lex_state = 101, .external_lex_state = 2}, + [1945] = {.lex_state = 101, .external_lex_state = 2}, + [1946] = {.lex_state = 100, .external_lex_state = 2}, + [1947] = {.lex_state = 0, .external_lex_state = 2}, + [1948] = {.lex_state = 101, .external_lex_state = 2}, + [1949] = {.lex_state = 101, .external_lex_state = 2}, + [1950] = {.lex_state = 100, .external_lex_state = 2}, + [1951] = {.lex_state = 100, .external_lex_state = 2}, + [1952] = {.lex_state = 100, .external_lex_state = 2}, + [1953] = {.lex_state = 101, .external_lex_state = 2}, + [1954] = {.lex_state = 9, .external_lex_state = 2}, + [1955] = {.lex_state = 101, .external_lex_state = 2}, + [1956] = {.lex_state = 100, .external_lex_state = 2}, + [1957] = {.lex_state = 9, .external_lex_state = 2}, + [1958] = {.lex_state = 9, .external_lex_state = 2}, + [1959] = {.lex_state = 9, .external_lex_state = 2}, + [1960] = {.lex_state = 100, .external_lex_state = 2}, + [1961] = {.lex_state = 9, .external_lex_state = 2}, + [1962] = {.lex_state = 101, .external_lex_state = 2}, + [1963] = {.lex_state = 9, .external_lex_state = 2}, + [1964] = {.lex_state = 9, .external_lex_state = 2}, + [1965] = {.lex_state = 9, .external_lex_state = 2}, + [1966] = {.lex_state = 101, .external_lex_state = 2}, + [1967] = {.lex_state = 101, .external_lex_state = 2}, + [1968] = {.lex_state = 101, .external_lex_state = 2}, + [1969] = {.lex_state = 9, .external_lex_state = 2}, + [1970] = {.lex_state = 100, .external_lex_state = 2}, + [1971] = {.lex_state = 101, .external_lex_state = 2}, + [1972] = {.lex_state = 101, .external_lex_state = 2}, + [1973] = {.lex_state = 100, .external_lex_state = 2}, + [1974] = {.lex_state = 9, .external_lex_state = 2}, + [1975] = {.lex_state = 101, .external_lex_state = 2}, + [1976] = {.lex_state = 101, .external_lex_state = 2}, + [1977] = {.lex_state = 9, .external_lex_state = 2}, + [1978] = {.lex_state = 100, .external_lex_state = 2}, + [1979] = {.lex_state = 101, .external_lex_state = 2}, + [1980] = {.lex_state = 101, .external_lex_state = 2}, + [1981] = {.lex_state = 38, .external_lex_state = 2}, + [1982] = {.lex_state = 9, .external_lex_state = 2}, + [1983] = {.lex_state = 9, .external_lex_state = 2}, + [1984] = {.lex_state = 9, .external_lex_state = 2}, + [1985] = {.lex_state = 17, .external_lex_state = 2}, + [1986] = {.lex_state = 17, .external_lex_state = 2}, + [1987] = {.lex_state = 17, .external_lex_state = 2}, + [1988] = {.lex_state = 17, .external_lex_state = 2}, + [1989] = {.lex_state = 101, .external_lex_state = 2}, + [1990] = {.lex_state = 17, .external_lex_state = 2}, + [1991] = {.lex_state = 17, .external_lex_state = 2}, + [1992] = {.lex_state = 17, .external_lex_state = 2}, + [1993] = {.lex_state = 101, .external_lex_state = 2}, + [1994] = {.lex_state = 17, .external_lex_state = 2}, + [1995] = {.lex_state = 100, .external_lex_state = 2}, + [1996] = {.lex_state = 100, .external_lex_state = 2}, + [1997] = {.lex_state = 100, .external_lex_state = 2}, + [1998] = {.lex_state = 100, .external_lex_state = 2}, + [1999] = {.lex_state = 100, .external_lex_state = 2}, + [2000] = {.lex_state = 100, .external_lex_state = 2}, + [2001] = {.lex_state = 100, .external_lex_state = 2}, + [2002] = {.lex_state = 100, .external_lex_state = 2}, + [2003] = {.lex_state = 38, .external_lex_state = 2}, + [2004] = {.lex_state = 100, .external_lex_state = 2}, + [2005] = {.lex_state = 101, .external_lex_state = 2}, + [2006] = {.lex_state = 100, .external_lex_state = 2}, + [2007] = {.lex_state = 100, .external_lex_state = 2}, + [2008] = {.lex_state = 101, .external_lex_state = 2}, + [2009] = {.lex_state = 101, .external_lex_state = 2}, + [2010] = {.lex_state = 101, .external_lex_state = 2}, + [2011] = {.lex_state = 9, .external_lex_state = 2}, + [2012] = {.lex_state = 100, .external_lex_state = 2}, + [2013] = {.lex_state = 100, .external_lex_state = 2}, + [2014] = {.lex_state = 101, .external_lex_state = 2}, + [2015] = {.lex_state = 101, .external_lex_state = 2}, + [2016] = {.lex_state = 38, .external_lex_state = 2}, + [2017] = {.lex_state = 101, .external_lex_state = 2}, + [2018] = {.lex_state = 101, .external_lex_state = 2}, + [2019] = {.lex_state = 101, .external_lex_state = 2}, + [2020] = {.lex_state = 100, .external_lex_state = 2}, + [2021] = {.lex_state = 101, .external_lex_state = 2}, + [2022] = {.lex_state = 101, .external_lex_state = 2}, + [2023] = {.lex_state = 101, .external_lex_state = 2}, + [2024] = {.lex_state = 101, .external_lex_state = 2}, + [2025] = {.lex_state = 100, .external_lex_state = 2}, + [2026] = {.lex_state = 100, .external_lex_state = 2}, + [2027] = {.lex_state = 100, .external_lex_state = 2}, + [2028] = {.lex_state = 101, .external_lex_state = 2}, + [2029] = {.lex_state = 24, .external_lex_state = 2}, + [2030] = {.lex_state = 41, .external_lex_state = 2}, + [2031] = {.lex_state = 101, .external_lex_state = 2}, + [2032] = {.lex_state = 24, .external_lex_state = 2}, + [2033] = {.lex_state = 101, .external_lex_state = 2}, + [2034] = {.lex_state = 41, .external_lex_state = 2}, + [2035] = {.lex_state = 19, .external_lex_state = 2}, + [2036] = {.lex_state = 101, .external_lex_state = 2}, + [2037] = {.lex_state = 38, .external_lex_state = 2}, + [2038] = {.lex_state = 24, .external_lex_state = 2}, + [2039] = {.lex_state = 101, .external_lex_state = 2}, + [2040] = {.lex_state = 41, .external_lex_state = 2}, + [2041] = {.lex_state = 101, .external_lex_state = 2}, + [2042] = {.lex_state = 101, .external_lex_state = 2}, + [2043] = {.lex_state = 24, .external_lex_state = 2}, + [2044] = {.lex_state = 24, .external_lex_state = 2}, + [2045] = {.lex_state = 24, .external_lex_state = 2}, + [2046] = {.lex_state = 24, .external_lex_state = 2}, + [2047] = {.lex_state = 24, .external_lex_state = 2}, + [2048] = {.lex_state = 101, .external_lex_state = 2}, + [2049] = {.lex_state = 101, .external_lex_state = 2}, + [2050] = {.lex_state = 101, .external_lex_state = 2}, + [2051] = {.lex_state = 24, .external_lex_state = 2}, + [2052] = {.lex_state = 101, .external_lex_state = 2}, + [2053] = {.lex_state = 24, .external_lex_state = 2}, + [2054] = {.lex_state = 101, .external_lex_state = 2}, + [2055] = {.lex_state = 41, .external_lex_state = 2}, + [2056] = {.lex_state = 24, .external_lex_state = 2}, + [2057] = {.lex_state = 101, .external_lex_state = 2}, + [2058] = {.lex_state = 101, .external_lex_state = 2}, + [2059] = {.lex_state = 101, .external_lex_state = 2}, + [2060] = {.lex_state = 101, .external_lex_state = 2}, + [2061] = {.lex_state = 24, .external_lex_state = 2}, + [2062] = {.lex_state = 24, .external_lex_state = 2}, + [2063] = {.lex_state = 24, .external_lex_state = 2}, + [2064] = {.lex_state = 38, .external_lex_state = 2}, + [2065] = {.lex_state = 101, .external_lex_state = 2}, + [2066] = {.lex_state = 24, .external_lex_state = 2}, + [2067] = {.lex_state = 101, .external_lex_state = 2}, + [2068] = {.lex_state = 24, .external_lex_state = 2}, + [2069] = {.lex_state = 24, .external_lex_state = 2}, + [2070] = {.lex_state = 41, .external_lex_state = 2}, + [2071] = {.lex_state = 41, .external_lex_state = 2}, + [2072] = {.lex_state = 24, .external_lex_state = 2}, + [2073] = {.lex_state = 41, .external_lex_state = 2}, + [2074] = {.lex_state = 101, .external_lex_state = 2}, + [2075] = {.lex_state = 101, .external_lex_state = 2}, + [2076] = {.lex_state = 24, .external_lex_state = 2}, + [2077] = {.lex_state = 41, .external_lex_state = 2}, + [2078] = {.lex_state = 24, .external_lex_state = 2}, + [2079] = {.lex_state = 101, .external_lex_state = 2}, + [2080] = {.lex_state = 24, .external_lex_state = 2}, + [2081] = {.lex_state = 101, .external_lex_state = 2}, + [2082] = {.lex_state = 101, .external_lex_state = 2}, + [2083] = {.lex_state = 101, .external_lex_state = 2}, + [2084] = {.lex_state = 101, .external_lex_state = 2}, + [2085] = {.lex_state = 101, .external_lex_state = 2}, + [2086] = {.lex_state = 101, .external_lex_state = 2}, + [2087] = {.lex_state = 101, .external_lex_state = 2}, + [2088] = {.lex_state = 101, .external_lex_state = 2}, + [2089] = {.lex_state = 101, .external_lex_state = 2}, + [2090] = {.lex_state = 102, .external_lex_state = 2}, + [2091] = {.lex_state = 101, .external_lex_state = 2}, + [2092] = {.lex_state = 101, .external_lex_state = 2}, + [2093] = {.lex_state = 101, .external_lex_state = 2}, + [2094] = {.lex_state = 101, .external_lex_state = 2}, + [2095] = {.lex_state = 102, .external_lex_state = 2}, + [2096] = {.lex_state = 101, .external_lex_state = 2}, + [2097] = {.lex_state = 101, .external_lex_state = 2}, + [2098] = {.lex_state = 101, .external_lex_state = 2}, + [2099] = {.lex_state = 101, .external_lex_state = 2}, + [2100] = {.lex_state = 101, .external_lex_state = 2}, + [2101] = {.lex_state = 101, .external_lex_state = 2}, + [2102] = {.lex_state = 101, .external_lex_state = 2}, + [2103] = {.lex_state = 101, .external_lex_state = 2}, + [2104] = {.lex_state = 101, .external_lex_state = 2}, + [2105] = {.lex_state = 101, .external_lex_state = 2}, + [2106] = {.lex_state = 101, .external_lex_state = 2}, + [2107] = {.lex_state = 101, .external_lex_state = 2}, + [2108] = {.lex_state = 101, .external_lex_state = 2}, + [2109] = {.lex_state = 101, .external_lex_state = 2}, + [2110] = {.lex_state = 23, .external_lex_state = 2}, + [2111] = {.lex_state = 101, .external_lex_state = 2}, + [2112] = {.lex_state = 101, .external_lex_state = 2}, + [2113] = {.lex_state = 101, .external_lex_state = 2}, + [2114] = {.lex_state = 101, .external_lex_state = 2}, + [2115] = {.lex_state = 23, .external_lex_state = 2}, + [2116] = {.lex_state = 101, .external_lex_state = 2}, + [2117] = {.lex_state = 101, .external_lex_state = 2}, + [2118] = {.lex_state = 101, .external_lex_state = 2}, + [2119] = {.lex_state = 38, .external_lex_state = 2}, + [2120] = {.lex_state = 101, .external_lex_state = 2}, + [2121] = {.lex_state = 101, .external_lex_state = 2}, + [2122] = {.lex_state = 101, .external_lex_state = 2}, + [2123] = {.lex_state = 38, .external_lex_state = 2}, + [2124] = {.lex_state = 101, .external_lex_state = 2}, + [2125] = {.lex_state = 19, .external_lex_state = 2}, + [2126] = {.lex_state = 101, .external_lex_state = 2}, + [2127] = {.lex_state = 101, .external_lex_state = 2}, + [2128] = {.lex_state = 38, .external_lex_state = 2}, + [2129] = {.lex_state = 19, .external_lex_state = 2}, + [2130] = {.lex_state = 19, .external_lex_state = 2}, + [2131] = {.lex_state = 101, .external_lex_state = 2}, + [2132] = {.lex_state = 19, .external_lex_state = 2}, + [2133] = {.lex_state = 19, .external_lex_state = 2}, + [2134] = {.lex_state = 19, .external_lex_state = 2}, + [2135] = {.lex_state = 19, .external_lex_state = 2}, + [2136] = {.lex_state = 19, .external_lex_state = 2}, + [2137] = {.lex_state = 100, .external_lex_state = 2}, + [2138] = {.lex_state = 100, .external_lex_state = 2}, + [2139] = {.lex_state = 19, .external_lex_state = 2}, + [2140] = {.lex_state = 19, .external_lex_state = 2}, + [2141] = {.lex_state = 101, .external_lex_state = 2}, + [2142] = {.lex_state = 101, .external_lex_state = 2}, + [2143] = {.lex_state = 19, .external_lex_state = 2}, + [2144] = {.lex_state = 19, .external_lex_state = 2}, + [2145] = {.lex_state = 19, .external_lex_state = 2}, + [2146] = {.lex_state = 19, .external_lex_state = 2}, + [2147] = {.lex_state = 19, .external_lex_state = 2}, + [2148] = {.lex_state = 19, .external_lex_state = 2}, + [2149] = {.lex_state = 19, .external_lex_state = 2}, + [2150] = {.lex_state = 19, .external_lex_state = 2}, + [2151] = {.lex_state = 19, .external_lex_state = 2}, + [2152] = {.lex_state = 19, .external_lex_state = 2}, + [2153] = {.lex_state = 101, .external_lex_state = 2}, + [2154] = {.lex_state = 38, .external_lex_state = 2}, + [2155] = {.lex_state = 19, .external_lex_state = 2}, + [2156] = {.lex_state = 19, .external_lex_state = 2}, + [2157] = {.lex_state = 19, .external_lex_state = 2}, + [2158] = {.lex_state = 101, .external_lex_state = 2}, + [2159] = {.lex_state = 100, .external_lex_state = 2}, + [2160] = {.lex_state = 100, .external_lex_state = 2}, + [2161] = {.lex_state = 38, .external_lex_state = 2}, + [2162] = {.lex_state = 101, .external_lex_state = 2}, + [2163] = {.lex_state = 17, .external_lex_state = 2}, + [2164] = {.lex_state = 12, .external_lex_state = 2}, + [2165] = {.lex_state = 38, .external_lex_state = 2}, + [2166] = {.lex_state = 101, .external_lex_state = 2}, + [2167] = {.lex_state = 101, .external_lex_state = 2}, + [2168] = {.lex_state = 101, .external_lex_state = 2}, + [2169] = {.lex_state = 38, .external_lex_state = 2}, + [2170] = {.lex_state = 101, .external_lex_state = 2}, + [2171] = {.lex_state = 12, .external_lex_state = 2}, + [2172] = {.lex_state = 12, .external_lex_state = 2}, + [2173] = {.lex_state = 17, .external_lex_state = 2}, + [2174] = {.lex_state = 101, .external_lex_state = 2}, + [2175] = {.lex_state = 101, .external_lex_state = 2}, + [2176] = {.lex_state = 38, .external_lex_state = 2}, + [2177] = {.lex_state = 17, .external_lex_state = 3}, + [2178] = {.lex_state = 101, .external_lex_state = 2}, + [2179] = {.lex_state = 20, .external_lex_state = 4}, + [2180] = {.lex_state = 101, .external_lex_state = 2}, + [2181] = {.lex_state = 17, .external_lex_state = 3}, + [2182] = {.lex_state = 17, .external_lex_state = 3}, + [2183] = {.lex_state = 17, .external_lex_state = 3}, + [2184] = {.lex_state = 20, .external_lex_state = 4}, + [2185] = {.lex_state = 17, .external_lex_state = 3}, + [2186] = {.lex_state = 38, .external_lex_state = 2}, + [2187] = {.lex_state = 38, .external_lex_state = 2}, + [2188] = {.lex_state = 38, .external_lex_state = 2}, + [2189] = {.lex_state = 20, .external_lex_state = 4}, + [2190] = {.lex_state = 20, .external_lex_state = 2}, + [2191] = {.lex_state = 102, .external_lex_state = 2}, + [2192] = {.lex_state = 20, .external_lex_state = 4}, + [2193] = {.lex_state = 17, .external_lex_state = 3}, + [2194] = {.lex_state = 101, .external_lex_state = 2}, + [2195] = {.lex_state = 17, .external_lex_state = 3}, + [2196] = {.lex_state = 38, .external_lex_state = 2}, + [2197] = {.lex_state = 20, .external_lex_state = 4}, + [2198] = {.lex_state = 20, .external_lex_state = 4}, + [2199] = {.lex_state = 20, .external_lex_state = 4}, + [2200] = {.lex_state = 20, .external_lex_state = 4}, + [2201] = {.lex_state = 101, .external_lex_state = 2}, + [2202] = {.lex_state = 20, .external_lex_state = 4}, + [2203] = {.lex_state = 101, .external_lex_state = 2}, + [2204] = {.lex_state = 38, .external_lex_state = 2}, + [2205] = {.lex_state = 17, .external_lex_state = 3}, + [2206] = {.lex_state = 17, .external_lex_state = 3}, + [2207] = {.lex_state = 101, .external_lex_state = 2}, + [2208] = {.lex_state = 20, .external_lex_state = 4}, + [2209] = {.lex_state = 17, .external_lex_state = 3}, + [2210] = {.lex_state = 20, .external_lex_state = 4}, + [2211] = {.lex_state = 17, .external_lex_state = 3}, + [2212] = {.lex_state = 33, .external_lex_state = 5}, + [2213] = {.lex_state = 101, .external_lex_state = 2}, + [2214] = {.lex_state = 101, .external_lex_state = 2}, + [2215] = {.lex_state = 38, .external_lex_state = 2}, + [2216] = {.lex_state = 0, .external_lex_state = 2}, + [2217] = {.lex_state = 38, .external_lex_state = 2}, + [2218] = {.lex_state = 33, .external_lex_state = 5}, + [2219] = {.lex_state = 33, .external_lex_state = 6}, + [2220] = {.lex_state = 100, .external_lex_state = 2}, + [2221] = {.lex_state = 38, .external_lex_state = 2}, + [2222] = {.lex_state = 0, .external_lex_state = 2}, + [2223] = {.lex_state = 101, .external_lex_state = 2}, + [2224] = {.lex_state = 101, .external_lex_state = 2}, + [2225] = {.lex_state = 33, .external_lex_state = 5}, + [2226] = {.lex_state = 33, .external_lex_state = 6}, + [2227] = {.lex_state = 101, .external_lex_state = 2}, + [2228] = {.lex_state = 101, .external_lex_state = 2}, + [2229] = {.lex_state = 17, .external_lex_state = 7}, + [2230] = {.lex_state = 3, .external_lex_state = 2}, + [2231] = {.lex_state = 20, .external_lex_state = 8}, + [2232] = {.lex_state = 100, .external_lex_state = 2}, + [2233] = {.lex_state = 101, .external_lex_state = 2}, + [2234] = {.lex_state = 38, .external_lex_state = 2}, + [2235] = {.lex_state = 33, .external_lex_state = 6}, + [2236] = {.lex_state = 33, .external_lex_state = 6}, + [2237] = {.lex_state = 17, .external_lex_state = 7}, + [2238] = {.lex_state = 20, .external_lex_state = 8}, + [2239] = {.lex_state = 101, .external_lex_state = 2}, + [2240] = {.lex_state = 33, .external_lex_state = 5}, + [2241] = {.lex_state = 33, .external_lex_state = 6}, + [2242] = {.lex_state = 17, .external_lex_state = 7}, + [2243] = {.lex_state = 20, .external_lex_state = 8}, + [2244] = {.lex_state = 101, .external_lex_state = 2}, + [2245] = {.lex_state = 0, .external_lex_state = 2}, + [2246] = {.lex_state = 17, .external_lex_state = 7}, + [2247] = {.lex_state = 17, .external_lex_state = 7}, + [2248] = {.lex_state = 101, .external_lex_state = 2}, + [2249] = {.lex_state = 101, .external_lex_state = 2}, + [2250] = {.lex_state = 38, .external_lex_state = 2}, + [2251] = {.lex_state = 33, .external_lex_state = 5}, + [2252] = {.lex_state = 38, .external_lex_state = 2}, + [2253] = {.lex_state = 17, .external_lex_state = 7}, + [2254] = {.lex_state = 20, .external_lex_state = 8}, + [2255] = {.lex_state = 33, .external_lex_state = 5}, + [2256] = {.lex_state = 33, .external_lex_state = 6}, + [2257] = {.lex_state = 17, .external_lex_state = 7}, + [2258] = {.lex_state = 20, .external_lex_state = 8}, + [2259] = {.lex_state = 101, .external_lex_state = 2}, + [2260] = {.lex_state = 100, .external_lex_state = 2}, + [2261] = {.lex_state = 102, .external_lex_state = 2}, + [2262] = {.lex_state = 33, .external_lex_state = 5}, + [2263] = {.lex_state = 33, .external_lex_state = 6}, + [2264] = {.lex_state = 20, .external_lex_state = 8}, + [2265] = {.lex_state = 17, .external_lex_state = 7}, + [2266] = {.lex_state = 20, .external_lex_state = 8}, + [2267] = {.lex_state = 33, .external_lex_state = 5}, + [2268] = {.lex_state = 33, .external_lex_state = 6}, + [2269] = {.lex_state = 17, .external_lex_state = 7}, + [2270] = {.lex_state = 20, .external_lex_state = 8}, + [2271] = {.lex_state = 38, .external_lex_state = 2}, + [2272] = {.lex_state = 33, .external_lex_state = 5}, + [2273] = {.lex_state = 33, .external_lex_state = 6}, + [2274] = {.lex_state = 101, .external_lex_state = 2}, + [2275] = {.lex_state = 17, .external_lex_state = 7}, + [2276] = {.lex_state = 20, .external_lex_state = 8}, + [2277] = {.lex_state = 33, .external_lex_state = 5}, + [2278] = {.lex_state = 33, .external_lex_state = 6}, + [2279] = {.lex_state = 17, .external_lex_state = 7}, + [2280] = {.lex_state = 20, .external_lex_state = 8}, + [2281] = {.lex_state = 101, .external_lex_state = 2}, + [2282] = {.lex_state = 20, .external_lex_state = 8}, + [2283] = {.lex_state = 33, .external_lex_state = 5}, + [2284] = {.lex_state = 101, .external_lex_state = 2}, + [2285] = {.lex_state = 101, .external_lex_state = 2}, + [2286] = {.lex_state = 101, .external_lex_state = 2}, + [2287] = {.lex_state = 101, .external_lex_state = 2}, + [2288] = {.lex_state = 33, .external_lex_state = 6}, + [2289] = {.lex_state = 101, .external_lex_state = 2}, + [2290] = {.lex_state = 100, .external_lex_state = 2}, + [2291] = {.lex_state = 100, .external_lex_state = 2}, + [2292] = {.lex_state = 101, .external_lex_state = 2}, + [2293] = {.lex_state = 0, .external_lex_state = 2}, + [2294] = {.lex_state = 33, .external_lex_state = 9}, + [2295] = {.lex_state = 22, .external_lex_state = 2}, + [2296] = {.lex_state = 33, .external_lex_state = 10}, + [2297] = {.lex_state = 33, .external_lex_state = 9}, + [2298] = {.lex_state = 33, .external_lex_state = 10}, + [2299] = {.lex_state = 22, .external_lex_state = 2}, + [2300] = {.lex_state = 22, .external_lex_state = 2}, + [2301] = {.lex_state = 101, .external_lex_state = 2}, + [2302] = {.lex_state = 100, .external_lex_state = 2}, + [2303] = {.lex_state = 33, .external_lex_state = 9}, + [2304] = {.lex_state = 33, .external_lex_state = 10}, + [2305] = {.lex_state = 33, .external_lex_state = 9}, + [2306] = {.lex_state = 101, .external_lex_state = 2}, + [2307] = {.lex_state = 102, .external_lex_state = 2}, + [2308] = {.lex_state = 101, .external_lex_state = 2}, + [2309] = {.lex_state = 3, .external_lex_state = 2}, + [2310] = {.lex_state = 101, .external_lex_state = 2}, + [2311] = {.lex_state = 101, .external_lex_state = 2}, + [2312] = {.lex_state = 0, .external_lex_state = 2}, + [2313] = {.lex_state = 32, .external_lex_state = 8}, + [2314] = {.lex_state = 22, .external_lex_state = 2}, + [2315] = {.lex_state = 101, .external_lex_state = 2}, + [2316] = {.lex_state = 101, .external_lex_state = 2}, + [2317] = {.lex_state = 33, .external_lex_state = 9}, + [2318] = {.lex_state = 33, .external_lex_state = 10}, + [2319] = {.lex_state = 101, .external_lex_state = 2}, + [2320] = {.lex_state = 0, .external_lex_state = 2}, + [2321] = {.lex_state = 22, .external_lex_state = 2}, + [2322] = {.lex_state = 101, .external_lex_state = 2}, + [2323] = {.lex_state = 33, .external_lex_state = 9}, + [2324] = {.lex_state = 33, .external_lex_state = 10}, + [2325] = {.lex_state = 102, .external_lex_state = 2}, + [2326] = {.lex_state = 33, .external_lex_state = 9}, + [2327] = {.lex_state = 0, .external_lex_state = 2}, + [2328] = {.lex_state = 33, .external_lex_state = 10}, + [2329] = {.lex_state = 33, .external_lex_state = 9}, + [2330] = {.lex_state = 33, .external_lex_state = 10}, + [2331] = {.lex_state = 33, .external_lex_state = 9}, + [2332] = {.lex_state = 33, .external_lex_state = 10}, + [2333] = {.lex_state = 22, .external_lex_state = 2}, + [2334] = {.lex_state = 33, .external_lex_state = 10}, + [2335] = {.lex_state = 100, .external_lex_state = 2}, + [2336] = {.lex_state = 22, .external_lex_state = 2}, + [2337] = {.lex_state = 101, .external_lex_state = 2}, + [2338] = {.lex_state = 33, .external_lex_state = 9}, + [2339] = {.lex_state = 33, .external_lex_state = 10}, + [2340] = {.lex_state = 22, .external_lex_state = 2}, + [2341] = {.lex_state = 33, .external_lex_state = 9}, + [2342] = {.lex_state = 33, .external_lex_state = 10}, + [2343] = {.lex_state = 22, .external_lex_state = 2}, + [2344] = {.lex_state = 0, .external_lex_state = 2}, + [2345] = {.lex_state = 101, .external_lex_state = 2}, + [2346] = {.lex_state = 101, .external_lex_state = 2}, + [2347] = {.lex_state = 101, .external_lex_state = 2}, + [2348] = {.lex_state = 101, .external_lex_state = 2}, + [2349] = {.lex_state = 101, .external_lex_state = 2}, + [2350] = {.lex_state = 101, .external_lex_state = 2}, + [2351] = {.lex_state = 100, .external_lex_state = 2}, + [2352] = {.lex_state = 29, .external_lex_state = 7}, + [2353] = {.lex_state = 101, .external_lex_state = 2}, + [2354] = {.lex_state = 22, .external_lex_state = 2}, + [2355] = {.lex_state = 0, .external_lex_state = 2}, + [2356] = {.lex_state = 101, .external_lex_state = 2}, + [2357] = {.lex_state = 22, .external_lex_state = 2}, + [2358] = {.lex_state = 101, .external_lex_state = 2}, + [2359] = {.lex_state = 101, .external_lex_state = 2}, + [2360] = {.lex_state = 0, .external_lex_state = 2}, + [2361] = {.lex_state = 100, .external_lex_state = 2}, + [2362] = {.lex_state = 17, .external_lex_state = 7}, + [2363] = {.lex_state = 0, .external_lex_state = 2}, + [2364] = {.lex_state = 100, .external_lex_state = 2}, + [2365] = {.lex_state = 0, .external_lex_state = 2}, + [2366] = {.lex_state = 100, .external_lex_state = 2}, + [2367] = {.lex_state = 20, .external_lex_state = 8}, + [2368] = {.lex_state = 100, .external_lex_state = 2}, + [2369] = {.lex_state = 100, .external_lex_state = 2}, + [2370] = {.lex_state = 100, .external_lex_state = 2}, + [2371] = {.lex_state = 100, .external_lex_state = 2}, + [2372] = {.lex_state = 22, .external_lex_state = 2}, + [2373] = {.lex_state = 100, .external_lex_state = 2}, + [2374] = {.lex_state = 35, .external_lex_state = 10}, + [2375] = {.lex_state = 100, .external_lex_state = 2}, + [2376] = {.lex_state = 100, .external_lex_state = 2}, + [2377] = {.lex_state = 100, .external_lex_state = 2}, + [2378] = {.lex_state = 100, .external_lex_state = 2}, + [2379] = {.lex_state = 3, .external_lex_state = 2}, + [2380] = {.lex_state = 100, .external_lex_state = 2}, + [2381] = {.lex_state = 100, .external_lex_state = 2}, + [2382] = {.lex_state = 100, .external_lex_state = 2}, + [2383] = {.lex_state = 100, .external_lex_state = 2}, + [2384] = {.lex_state = 101, .external_lex_state = 2}, + [2385] = {.lex_state = 101, .external_lex_state = 2}, + [2386] = {.lex_state = 100, .external_lex_state = 2}, + [2387] = {.lex_state = 100, .external_lex_state = 2}, + [2388] = {.lex_state = 100, .external_lex_state = 2}, + [2389] = {.lex_state = 17, .external_lex_state = 7}, + [2390] = {.lex_state = 100, .external_lex_state = 2}, + [2391] = {.lex_state = 100, .external_lex_state = 2}, + [2392] = {.lex_state = 38, .external_lex_state = 2}, + [2393] = {.lex_state = 0, .external_lex_state = 2}, + [2394] = {.lex_state = 100, .external_lex_state = 2}, + [2395] = {.lex_state = 100, .external_lex_state = 2}, + [2396] = {.lex_state = 100, .external_lex_state = 2}, + [2397] = {.lex_state = 100, .external_lex_state = 2}, + [2398] = {.lex_state = 22, .external_lex_state = 2}, + [2399] = {.lex_state = 0, .external_lex_state = 2}, + [2400] = {.lex_state = 100, .external_lex_state = 2}, + [2401] = {.lex_state = 101, .external_lex_state = 2}, + [2402] = {.lex_state = 100, .external_lex_state = 2}, + [2403] = {.lex_state = 100, .external_lex_state = 2}, + [2404] = {.lex_state = 100, .external_lex_state = 2}, + [2405] = {.lex_state = 0, .external_lex_state = 2}, + [2406] = {.lex_state = 100, .external_lex_state = 2}, + [2407] = {.lex_state = 101, .external_lex_state = 2}, + [2408] = {.lex_state = 101, .external_lex_state = 2}, + [2409] = {.lex_state = 0, .external_lex_state = 2}, + [2410] = {.lex_state = 100, .external_lex_state = 2}, + [2411] = {.lex_state = 20, .external_lex_state = 8}, + [2412] = {.lex_state = 100, .external_lex_state = 2}, + [2413] = {.lex_state = 101, .external_lex_state = 2}, + [2414] = {.lex_state = 0, .external_lex_state = 2}, + [2415] = {.lex_state = 100, .external_lex_state = 2}, + [2416] = {.lex_state = 100, .external_lex_state = 2}, + [2417] = {.lex_state = 0, .external_lex_state = 2}, + [2418] = {.lex_state = 101, .external_lex_state = 2}, + [2419] = {.lex_state = 100, .external_lex_state = 2}, + [2420] = {.lex_state = 100, .external_lex_state = 2}, + [2421] = {.lex_state = 0, .external_lex_state = 2}, + [2422] = {.lex_state = 22, .external_lex_state = 2}, + [2423] = {.lex_state = 35, .external_lex_state = 9}, + [2424] = {.lex_state = 101, .external_lex_state = 2}, + [2425] = {.lex_state = 0, .external_lex_state = 2}, + [2426] = {.lex_state = 100, .external_lex_state = 2}, + [2427] = {.lex_state = 0, .external_lex_state = 2}, + [2428] = {.lex_state = 100, .external_lex_state = 2}, + [2429] = {.lex_state = 100, .external_lex_state = 2}, + [2430] = {.lex_state = 100, .external_lex_state = 2}, + [2431] = {.lex_state = 100, .external_lex_state = 2}, + [2432] = {.lex_state = 100, .external_lex_state = 2}, + [2433] = {.lex_state = 100, .external_lex_state = 2}, + [2434] = {.lex_state = 100, .external_lex_state = 2}, + [2435] = {.lex_state = 100, .external_lex_state = 2}, + [2436] = {.lex_state = 0, .external_lex_state = 2}, + [2437] = {.lex_state = 0, .external_lex_state = 2}, + [2438] = {.lex_state = 100, .external_lex_state = 2}, + [2439] = {.lex_state = 0, .external_lex_state = 2}, + [2440] = {.lex_state = 100, .external_lex_state = 2}, + [2441] = {.lex_state = 100, .external_lex_state = 2}, + [2442] = {.lex_state = 100, .external_lex_state = 2}, + [2443] = {.lex_state = 100, .external_lex_state = 2}, + [2444] = {.lex_state = 101, .external_lex_state = 2}, + [2445] = {.lex_state = 101, .external_lex_state = 2}, + [2446] = {.lex_state = 3, .external_lex_state = 2}, + [2447] = {.lex_state = 100, .external_lex_state = 2}, + [2448] = {.lex_state = 100, .external_lex_state = 2}, + [2449] = {.lex_state = 101, .external_lex_state = 2}, + [2450] = {.lex_state = 0, .external_lex_state = 2}, + [2451] = {.lex_state = 101, .external_lex_state = 2}, + [2452] = {.lex_state = 101, .external_lex_state = 2}, + [2453] = {.lex_state = 100, .external_lex_state = 2}, + [2454] = {.lex_state = 0, .external_lex_state = 2}, + [2455] = {.lex_state = 101, .external_lex_state = 2}, + [2456] = {.lex_state = 100, .external_lex_state = 2}, + [2457] = {.lex_state = 100, .external_lex_state = 2}, + [2458] = {.lex_state = 100, .external_lex_state = 2}, + [2459] = {.lex_state = 38, .external_lex_state = 2}, + [2460] = {.lex_state = 0, .external_lex_state = 2}, + [2461] = {.lex_state = 100, .external_lex_state = 2}, + [2462] = {.lex_state = 101, .external_lex_state = 2}, + [2463] = {.lex_state = 100, .external_lex_state = 2}, + [2464] = {.lex_state = 101, .external_lex_state = 2}, + [2465] = {.lex_state = 101, .external_lex_state = 2}, + [2466] = {.lex_state = 101, .external_lex_state = 2}, + [2467] = {.lex_state = 0, .external_lex_state = 2}, + [2468] = {.lex_state = 101, .external_lex_state = 2}, + [2469] = {.lex_state = 100, .external_lex_state = 2}, + [2470] = {.lex_state = 101, .external_lex_state = 2}, + [2471] = {.lex_state = 101, .external_lex_state = 2}, + [2472] = {.lex_state = 101, .external_lex_state = 2}, + [2473] = {.lex_state = 20, .external_lex_state = 4}, + [2474] = {.lex_state = 100, .external_lex_state = 2}, + [2475] = {.lex_state = 33, .external_lex_state = 9}, + [2476] = {.lex_state = 101, .external_lex_state = 2}, + [2477] = {.lex_state = 101, .external_lex_state = 2}, + [2478] = {.lex_state = 100, .external_lex_state = 2}, + [2479] = {.lex_state = 100, .external_lex_state = 2}, + [2480] = {.lex_state = 0, .external_lex_state = 2}, + [2481] = {.lex_state = 101, .external_lex_state = 2}, + [2482] = {.lex_state = 101, .external_lex_state = 2}, + [2483] = {.lex_state = 20, .external_lex_state = 4}, + [2484] = {.lex_state = 100, .external_lex_state = 2}, + [2485] = {.lex_state = 101, .external_lex_state = 2}, + [2486] = {.lex_state = 101, .external_lex_state = 2}, + [2487] = {.lex_state = 100, .external_lex_state = 2}, + [2488] = {.lex_state = 101, .external_lex_state = 2}, + [2489] = {.lex_state = 100, .external_lex_state = 2}, + [2490] = {.lex_state = 101, .external_lex_state = 2}, + [2491] = {.lex_state = 0, .external_lex_state = 2}, + [2492] = {.lex_state = 101, .external_lex_state = 2}, + [2493] = {.lex_state = 100, .external_lex_state = 2}, + [2494] = {.lex_state = 100, .external_lex_state = 2}, + [2495] = {.lex_state = 3, .external_lex_state = 2}, + [2496] = {.lex_state = 101, .external_lex_state = 2}, + [2497] = {.lex_state = 101, .external_lex_state = 2}, + [2498] = {.lex_state = 101, .external_lex_state = 2}, + [2499] = {.lex_state = 0, .external_lex_state = 2}, + [2500] = {.lex_state = 33, .external_lex_state = 10}, + [2501] = {.lex_state = 100, .external_lex_state = 2}, + [2502] = {.lex_state = 3, .external_lex_state = 2}, + [2503] = {.lex_state = 101, .external_lex_state = 2}, + [2504] = {.lex_state = 3, .external_lex_state = 2}, + [2505] = {.lex_state = 101, .external_lex_state = 2}, + [2506] = {.lex_state = 17, .external_lex_state = 3}, + [2507] = {.lex_state = 100, .external_lex_state = 2}, + [2508] = {.lex_state = 0, .external_lex_state = 2}, + [2509] = {.lex_state = 100, .external_lex_state = 2}, + [2510] = {.lex_state = 100, .external_lex_state = 2}, + [2511] = {.lex_state = 101, .external_lex_state = 2}, + [2512] = {.lex_state = 0, .external_lex_state = 2}, + [2513] = {.lex_state = 20, .external_lex_state = 4}, + [2514] = {.lex_state = 20, .external_lex_state = 4}, + [2515] = {.lex_state = 0, .external_lex_state = 2}, + [2516] = {.lex_state = 101, .external_lex_state = 2}, + [2517] = {.lex_state = 100, .external_lex_state = 2}, + [2518] = {.lex_state = 17, .external_lex_state = 3}, + [2519] = {.lex_state = 17, .external_lex_state = 3}, + [2520] = {.lex_state = 0, .external_lex_state = 2}, + [2521] = {.lex_state = 100, .external_lex_state = 2}, + [2522] = {.lex_state = 101, .external_lex_state = 2}, + [2523] = {.lex_state = 20, .external_lex_state = 4}, + [2524] = {.lex_state = 100, .external_lex_state = 2}, + [2525] = {.lex_state = 0, .external_lex_state = 2}, + [2526] = {.lex_state = 100, .external_lex_state = 2}, + [2527] = {.lex_state = 100, .external_lex_state = 2}, + [2528] = {.lex_state = 100, .external_lex_state = 2}, + [2529] = {.lex_state = 101, .external_lex_state = 2}, + [2530] = {.lex_state = 100, .external_lex_state = 2}, + [2531] = {.lex_state = 33, .external_lex_state = 9}, + [2532] = {.lex_state = 101, .external_lex_state = 2}, + [2533] = {.lex_state = 101, .external_lex_state = 2}, + [2534] = {.lex_state = 100, .external_lex_state = 2}, + [2535] = {.lex_state = 101, .external_lex_state = 2}, + [2536] = {.lex_state = 100, .external_lex_state = 2}, + [2537] = {.lex_state = 100, .external_lex_state = 2}, + [2538] = {.lex_state = 101, .external_lex_state = 2}, + [2539] = {.lex_state = 0, .external_lex_state = 2}, + [2540] = {.lex_state = 101, .external_lex_state = 2}, + [2541] = {.lex_state = 102, .external_lex_state = 2}, + [2542] = {.lex_state = 0, .external_lex_state = 2}, + [2543] = {.lex_state = 100, .external_lex_state = 2}, + [2544] = {.lex_state = 33, .external_lex_state = 10}, + [2545] = {.lex_state = 0, .external_lex_state = 2}, + [2546] = {.lex_state = 0, .external_lex_state = 2}, + [2547] = {.lex_state = 0, .external_lex_state = 2}, + [2548] = {.lex_state = 101, .external_lex_state = 2}, + [2549] = {.lex_state = 101, .external_lex_state = 2}, + [2550] = {.lex_state = 100, .external_lex_state = 2}, + [2551] = {.lex_state = 100, .external_lex_state = 2}, + [2552] = {.lex_state = 0, .external_lex_state = 2}, + [2553] = {.lex_state = 17, .external_lex_state = 3}, + [2554] = {.lex_state = 17, .external_lex_state = 3}, + [2555] = {.lex_state = 100, .external_lex_state = 2}, + [2556] = {.lex_state = 101, .external_lex_state = 2}, + [2557] = {.lex_state = 101, .external_lex_state = 2}, + [2558] = {.lex_state = 102, .external_lex_state = 2}, + [2559] = {.lex_state = 101, .external_lex_state = 2}, + [2560] = {.lex_state = 100, .external_lex_state = 2}, + [2561] = {.lex_state = 101, .external_lex_state = 2}, + [2562] = {.lex_state = 102, .external_lex_state = 2}, + [2563] = {.lex_state = 101, .external_lex_state = 2}, + [2564] = {.lex_state = 101, .external_lex_state = 2}, + [2565] = {.lex_state = 101, .external_lex_state = 2}, + [2566] = {.lex_state = 101, .external_lex_state = 2}, + [2567] = {.lex_state = 101, .external_lex_state = 2}, + [2568] = {.lex_state = 101, .external_lex_state = 2}, + [2569] = {.lex_state = 101, .external_lex_state = 2}, + [2570] = {.lex_state = 101, .external_lex_state = 2}, + [2571] = {.lex_state = 101, .external_lex_state = 2}, + [2572] = {.lex_state = 101, .external_lex_state = 2}, + [2573] = {.lex_state = 101, .external_lex_state = 2}, + [2574] = {.lex_state = 100, .external_lex_state = 2}, + [2575] = {.lex_state = 100, .external_lex_state = 2}, + [2576] = {.lex_state = 101, .external_lex_state = 2}, + [2577] = {.lex_state = 33, .external_lex_state = 6}, + [2578] = {.lex_state = 101, .external_lex_state = 2}, + [2579] = {.lex_state = 3, .external_lex_state = 2}, + [2580] = {.lex_state = 101, .external_lex_state = 2}, + [2581] = {.lex_state = 101, .external_lex_state = 2}, + [2582] = {.lex_state = 0, .external_lex_state = 2}, + [2583] = {.lex_state = 0, .external_lex_state = 2}, + [2584] = {.lex_state = 101, .external_lex_state = 2}, + [2585] = {.lex_state = 101, .external_lex_state = 2}, + [2586] = {.lex_state = 101, .external_lex_state = 2}, + [2587] = {.lex_state = 101, .external_lex_state = 2}, + [2588] = {.lex_state = 101, .external_lex_state = 2}, + [2589] = {.lex_state = 100, .external_lex_state = 2}, + [2590] = {.lex_state = 100, .external_lex_state = 2}, + [2591] = {.lex_state = 100, .external_lex_state = 2}, + [2592] = {.lex_state = 101, .external_lex_state = 2}, + [2593] = {.lex_state = 100, .external_lex_state = 2}, + [2594] = {.lex_state = 102, .external_lex_state = 2}, + [2595] = {.lex_state = 101, .external_lex_state = 2}, + [2596] = {.lex_state = 33, .external_lex_state = 5}, + [2597] = {.lex_state = 0, .external_lex_state = 2}, + [2598] = {.lex_state = 101, .external_lex_state = 2}, + [2599] = {.lex_state = 101, .external_lex_state = 2}, + [2600] = {.lex_state = 101, .external_lex_state = 2}, + [2601] = {.lex_state = 101, .external_lex_state = 2}, + [2602] = {.lex_state = 101, .external_lex_state = 2}, + [2603] = {.lex_state = 33, .external_lex_state = 5}, + [2604] = {.lex_state = 101, .external_lex_state = 2}, + [2605] = {.lex_state = 101, .external_lex_state = 2}, + [2606] = {.lex_state = 101, .external_lex_state = 2}, + [2607] = {.lex_state = 101, .external_lex_state = 2}, + [2608] = {.lex_state = 101, .external_lex_state = 2}, + [2609] = {.lex_state = 101, .external_lex_state = 2}, + [2610] = {.lex_state = 3, .external_lex_state = 2}, + [2611] = {.lex_state = 101, .external_lex_state = 2}, + [2612] = {.lex_state = 33, .external_lex_state = 6}, + [2613] = {.lex_state = 33, .external_lex_state = 5}, + [2614] = {.lex_state = 33, .external_lex_state = 6}, + [2615] = {.lex_state = 101, .external_lex_state = 2}, + [2616] = {.lex_state = 102, .external_lex_state = 2}, + [2617] = {.lex_state = 101, .external_lex_state = 2}, + [2618] = {.lex_state = 33, .external_lex_state = 6}, + [2619] = {.lex_state = 101, .external_lex_state = 2}, + [2620] = {.lex_state = 100, .external_lex_state = 2}, + [2621] = {.lex_state = 100, .external_lex_state = 2}, + [2622] = {.lex_state = 101, .external_lex_state = 2}, + [2623] = {.lex_state = 0, .external_lex_state = 2}, + [2624] = {.lex_state = 33, .external_lex_state = 5}, + [2625] = {.lex_state = 33, .external_lex_state = 5}, + [2626] = {.lex_state = 33, .external_lex_state = 6}, + [2627] = {.lex_state = 101, .external_lex_state = 2}, + [2628] = {.lex_state = 101, .external_lex_state = 2}, + [2629] = {.lex_state = 100, .external_lex_state = 2}, + [2630] = {.lex_state = 101, .external_lex_state = 2}, + [2631] = {.lex_state = 0, .external_lex_state = 2}, + [2632] = {.lex_state = 101, .external_lex_state = 2}, + [2633] = {.lex_state = 100, .external_lex_state = 2}, + [2634] = {.lex_state = 101, .external_lex_state = 2}, + [2635] = {.lex_state = 100, .external_lex_state = 2}, + [2636] = {.lex_state = 100, .external_lex_state = 2}, + [2637] = {.lex_state = 100, .external_lex_state = 2}, + [2638] = {.lex_state = 100, .external_lex_state = 2}, + [2639] = {.lex_state = 100, .external_lex_state = 2}, + [2640] = {.lex_state = 0, .external_lex_state = 2}, + [2641] = {.lex_state = 100, .external_lex_state = 2}, + [2642] = {.lex_state = 0, .external_lex_state = 2}, + [2643] = {.lex_state = 100, .external_lex_state = 2}, + [2644] = {.lex_state = 100, .external_lex_state = 2}, + [2645] = {.lex_state = 100, .external_lex_state = 2}, + [2646] = {.lex_state = 100, .external_lex_state = 2}, + [2647] = {.lex_state = 100, .external_lex_state = 2}, + [2648] = {.lex_state = 100, .external_lex_state = 2}, + [2649] = {.lex_state = 100, .external_lex_state = 2}, + [2650] = {.lex_state = 101, .external_lex_state = 2}, + [2651] = {.lex_state = 101, .external_lex_state = 2}, + [2652] = {.lex_state = 101, .external_lex_state = 2}, + [2653] = {.lex_state = 0, .external_lex_state = 2}, + [2654] = {.lex_state = 101, .external_lex_state = 2}, + [2655] = {.lex_state = 101, .external_lex_state = 2}, + [2656] = {.lex_state = 100, .external_lex_state = 2}, + [2657] = {.lex_state = 100, .external_lex_state = 2}, + [2658] = {.lex_state = 101, .external_lex_state = 2}, + [2659] = {.lex_state = 101, .external_lex_state = 2}, + [2660] = {.lex_state = 101, .external_lex_state = 2}, + [2661] = {.lex_state = 0, .external_lex_state = 2}, + [2662] = {.lex_state = 101, .external_lex_state = 2}, + [2663] = {.lex_state = 101, .external_lex_state = 2}, + [2664] = {.lex_state = 0, .external_lex_state = 2}, + [2665] = {.lex_state = 100, .external_lex_state = 2}, + [2666] = {.lex_state = 101, .external_lex_state = 2}, + [2667] = {.lex_state = 101, .external_lex_state = 2}, + [2668] = {.lex_state = 101, .external_lex_state = 2}, + [2669] = {.lex_state = 101, .external_lex_state = 2}, + [2670] = {.lex_state = 100, .external_lex_state = 2}, + [2671] = {.lex_state = 0, .external_lex_state = 2}, + [2672] = {.lex_state = 101, .external_lex_state = 2}, + [2673] = {.lex_state = 100, .external_lex_state = 2}, + [2674] = {.lex_state = 100, .external_lex_state = 2}, + [2675] = {.lex_state = 100, .external_lex_state = 2}, + [2676] = {.lex_state = 100, .external_lex_state = 2}, + [2677] = {.lex_state = 101, .external_lex_state = 2}, + [2678] = {.lex_state = 101, .external_lex_state = 2}, + [2679] = {.lex_state = 100, .external_lex_state = 2}, + [2680] = {.lex_state = 100, .external_lex_state = 2}, + [2681] = {.lex_state = 0, .external_lex_state = 2}, + [2682] = {.lex_state = 101, .external_lex_state = 2}, + [2683] = {.lex_state = 101, .external_lex_state = 2}, + [2684] = {.lex_state = 101, .external_lex_state = 2}, + [2685] = {.lex_state = 101, .external_lex_state = 2}, + [2686] = {.lex_state = 101, .external_lex_state = 2}, + [2687] = {.lex_state = 101, .external_lex_state = 2}, + [2688] = {.lex_state = 101, .external_lex_state = 2}, + [2689] = {.lex_state = 0, .external_lex_state = 2}, + [2690] = {.lex_state = 101, .external_lex_state = 2}, + [2691] = {.lex_state = 101, .external_lex_state = 2}, + [2692] = {.lex_state = 101, .external_lex_state = 2}, + [2693] = {.lex_state = 101, .external_lex_state = 2}, + [2694] = {.lex_state = 101, .external_lex_state = 2}, + [2695] = {.lex_state = 100, .external_lex_state = 2}, + [2696] = {.lex_state = 100, .external_lex_state = 2}, + [2697] = {.lex_state = 101, .external_lex_state = 2}, + [2698] = {.lex_state = 101, .external_lex_state = 2}, + [2699] = {.lex_state = 100, .external_lex_state = 2}, + [2700] = {.lex_state = 101, .external_lex_state = 2}, + [2701] = {.lex_state = 101, .external_lex_state = 2}, + [2702] = {.lex_state = 101, .external_lex_state = 2}, + [2703] = {.lex_state = 101, .external_lex_state = 2}, + [2704] = {.lex_state = 101, .external_lex_state = 2}, + [2705] = {.lex_state = 0, .external_lex_state = 2}, + [2706] = {.lex_state = 101, .external_lex_state = 2}, + [2707] = {.lex_state = 101, .external_lex_state = 2}, + [2708] = {.lex_state = 0, .external_lex_state = 2}, + [2709] = {.lex_state = 101, .external_lex_state = 2}, + [2710] = {.lex_state = 0, .external_lex_state = 2}, + [2711] = {.lex_state = 0, .external_lex_state = 2}, + [2712] = {.lex_state = 0, .external_lex_state = 2}, + [2713] = {.lex_state = 100, .external_lex_state = 2}, + [2714] = {.lex_state = 0, .external_lex_state = 2}, + [2715] = {.lex_state = 0, .external_lex_state = 2}, + [2716] = {.lex_state = 0, .external_lex_state = 2}, + [2717] = {.lex_state = 101, .external_lex_state = 2}, + [2718] = {.lex_state = 101, .external_lex_state = 2}, + [2719] = {.lex_state = 0, .external_lex_state = 2}, + [2720] = {.lex_state = 0, .external_lex_state = 2}, + [2721] = {.lex_state = 101, .external_lex_state = 2}, + [2722] = {.lex_state = 100, .external_lex_state = 2}, + [2723] = {.lex_state = 0, .external_lex_state = 2}, + [2724] = {.lex_state = 0, .external_lex_state = 2}, + [2725] = {.lex_state = 101, .external_lex_state = 2}, + [2726] = {.lex_state = 0, .external_lex_state = 2}, + [2727] = {.lex_state = 101, .external_lex_state = 2}, + [2728] = {.lex_state = 100, .external_lex_state = 2}, + [2729] = {.lex_state = 0, .external_lex_state = 2}, + [2730] = {.lex_state = 101, .external_lex_state = 2}, + [2731] = {.lex_state = 100, .external_lex_state = 2}, + [2732] = {.lex_state = 0, .external_lex_state = 2}, + [2733] = {.lex_state = 100, .external_lex_state = 2}, + [2734] = {.lex_state = 101, .external_lex_state = 2}, + [2735] = {.lex_state = 0, .external_lex_state = 2}, + [2736] = {.lex_state = 101, .external_lex_state = 2}, + [2737] = {.lex_state = 0, .external_lex_state = 2}, + [2738] = {.lex_state = 0, .external_lex_state = 2}, + [2739] = {.lex_state = 101, .external_lex_state = 2}, + [2740] = {.lex_state = 101, .external_lex_state = 2}, + [2741] = {.lex_state = 100, .external_lex_state = 2}, + [2742] = {.lex_state = 101, .external_lex_state = 2}, + [2743] = {.lex_state = 0, .external_lex_state = 2}, + [2744] = {.lex_state = 101, .external_lex_state = 2}, + [2745] = {.lex_state = 0, .external_lex_state = 2}, + [2746] = {.lex_state = 0, .external_lex_state = 2}, + [2747] = {.lex_state = 0, .external_lex_state = 2}, + [2748] = {.lex_state = 0, .external_lex_state = 2}, + [2749] = {.lex_state = 0, .external_lex_state = 2}, + [2750] = {.lex_state = 0, .external_lex_state = 2}, + [2751] = {.lex_state = 0, .external_lex_state = 2}, + [2752] = {.lex_state = 0, .external_lex_state = 2}, + [2753] = {.lex_state = 0, .external_lex_state = 2}, + [2754] = {.lex_state = 101, .external_lex_state = 2}, + [2755] = {.lex_state = 101, .external_lex_state = 2}, + [2756] = {.lex_state = 0, .external_lex_state = 2}, + [2757] = {.lex_state = 0, .external_lex_state = 2}, + [2758] = {.lex_state = 101, .external_lex_state = 2}, + [2759] = {.lex_state = 0, .external_lex_state = 2}, + [2760] = {.lex_state = 100, .external_lex_state = 2}, + [2761] = {.lex_state = 101, .external_lex_state = 2}, + [2762] = {.lex_state = 0, .external_lex_state = 2}, + [2763] = {.lex_state = 0, .external_lex_state = 2}, + [2764] = {.lex_state = 0, .external_lex_state = 2}, + [2765] = {.lex_state = 0, .external_lex_state = 2}, + [2766] = {.lex_state = 0, .external_lex_state = 2}, + [2767] = {.lex_state = 54, .external_lex_state = 2}, + [2768] = {.lex_state = 0, .external_lex_state = 2}, + [2769] = {.lex_state = 100, .external_lex_state = 2}, + [2770] = {.lex_state = 0, .external_lex_state = 2}, + [2771] = {.lex_state = 101, .external_lex_state = 2}, + [2772] = {.lex_state = 0, .external_lex_state = 2}, + [2773] = {.lex_state = 101, .external_lex_state = 2}, + [2774] = {.lex_state = 101, .external_lex_state = 2}, + [2775] = {.lex_state = 101, .external_lex_state = 2}, + [2776] = {.lex_state = 100, .external_lex_state = 2}, + [2777] = {.lex_state = 0, .external_lex_state = 2}, + [2778] = {.lex_state = 101, .external_lex_state = 2}, + [2779] = {.lex_state = 0, .external_lex_state = 2}, + [2780] = {.lex_state = 100, .external_lex_state = 2}, + [2781] = {.lex_state = 0, .external_lex_state = 2}, + [2782] = {.lex_state = 0, .external_lex_state = 2}, + [2783] = {.lex_state = 0, .external_lex_state = 2}, + [2784] = {.lex_state = 100, .external_lex_state = 2}, + [2785] = {.lex_state = 0, .external_lex_state = 2}, + [2786] = {.lex_state = 0, .external_lex_state = 2}, + [2787] = {.lex_state = 0, .external_lex_state = 2}, + [2788] = {.lex_state = 0, .external_lex_state = 2}, + [2789] = {.lex_state = 101, .external_lex_state = 2}, + [2790] = {.lex_state = 100, .external_lex_state = 2}, + [2791] = {.lex_state = 101, .external_lex_state = 2}, + [2792] = {.lex_state = 0, .external_lex_state = 2}, + [2793] = {.lex_state = 0, .external_lex_state = 2}, + [2794] = {.lex_state = 0, .external_lex_state = 2}, + [2795] = {.lex_state = 0, .external_lex_state = 2}, + [2796] = {.lex_state = 0, .external_lex_state = 2}, + [2797] = {.lex_state = 0, .external_lex_state = 2}, + [2798] = {.lex_state = 0, .external_lex_state = 2}, + [2799] = {.lex_state = 0, .external_lex_state = 2}, + [2800] = {.lex_state = 0, .external_lex_state = 2}, + [2801] = {.lex_state = 0, .external_lex_state = 2}, + [2802] = {.lex_state = 101, .external_lex_state = 2}, + [2803] = {.lex_state = 101, .external_lex_state = 2}, + [2804] = {.lex_state = 100, .external_lex_state = 2}, + [2805] = {.lex_state = 101, .external_lex_state = 2}, + [2806] = {.lex_state = 0, .external_lex_state = 2}, + [2807] = {.lex_state = 0, .external_lex_state = 2}, + [2808] = {.lex_state = 0, .external_lex_state = 2}, + [2809] = {.lex_state = 0, .external_lex_state = 2}, + [2810] = {.lex_state = 0, .external_lex_state = 2}, + [2811] = {.lex_state = 0, .external_lex_state = 2}, + [2812] = {.lex_state = 0, .external_lex_state = 2}, + [2813] = {.lex_state = 101, .external_lex_state = 2}, + [2814] = {.lex_state = 0, .external_lex_state = 2}, + [2815] = {.lex_state = 101, .external_lex_state = 2}, + [2816] = {.lex_state = 0, .external_lex_state = 2}, + [2817] = {.lex_state = 0, .external_lex_state = 2}, + [2818] = {.lex_state = 0, .external_lex_state = 2}, + [2819] = {.lex_state = 0, .external_lex_state = 2}, + [2820] = {.lex_state = 0, .external_lex_state = 2}, + [2821] = {.lex_state = 0, .external_lex_state = 2}, + [2822] = {.lex_state = 100, .external_lex_state = 2}, + [2823] = {.lex_state = 0, .external_lex_state = 2}, + [2824] = {.lex_state = 0, .external_lex_state = 2}, + [2825] = {.lex_state = 0, .external_lex_state = 2}, + [2826] = {.lex_state = 0, .external_lex_state = 2}, + [2827] = {.lex_state = 0, .external_lex_state = 2}, + [2828] = {.lex_state = 0, .external_lex_state = 2}, + [2829] = {.lex_state = 100, .external_lex_state = 2}, + [2830] = {.lex_state = 100, .external_lex_state = 2}, + [2831] = {.lex_state = 0, .external_lex_state = 2}, + [2832] = {.lex_state = 0, .external_lex_state = 2}, + [2833] = {.lex_state = 0, .external_lex_state = 2}, + [2834] = {.lex_state = 0, .external_lex_state = 2}, + [2835] = {.lex_state = 0, .external_lex_state = 2}, + [2836] = {.lex_state = 101, .external_lex_state = 2}, + [2837] = {.lex_state = 0, .external_lex_state = 2}, + [2838] = {.lex_state = 0, .external_lex_state = 2}, + [2839] = {.lex_state = 101, .external_lex_state = 2}, + [2840] = {.lex_state = 0, .external_lex_state = 2}, + [2841] = {.lex_state = 0, .external_lex_state = 2}, + [2842] = {.lex_state = 0, .external_lex_state = 2}, + [2843] = {.lex_state = 54, .external_lex_state = 2}, + [2844] = {.lex_state = 0, .external_lex_state = 2}, + [2845] = {.lex_state = 101, .external_lex_state = 2}, + [2846] = {.lex_state = 100, .external_lex_state = 2}, + [2847] = {.lex_state = 0, .external_lex_state = 2}, + [2848] = {.lex_state = 0, .external_lex_state = 2}, + [2849] = {.lex_state = 0, .external_lex_state = 2}, + [2850] = {.lex_state = 101, .external_lex_state = 2}, + [2851] = {.lex_state = 0, .external_lex_state = 2}, + [2852] = {.lex_state = 100, .external_lex_state = 2}, + [2853] = {.lex_state = 100, .external_lex_state = 2}, + [2854] = {.lex_state = 0, .external_lex_state = 2}, + [2855] = {.lex_state = 100, .external_lex_state = 2}, + [2856] = {.lex_state = 0, .external_lex_state = 2}, + [2857] = {.lex_state = 0, .external_lex_state = 2}, + [2858] = {.lex_state = 0, .external_lex_state = 2}, + [2859] = {.lex_state = 100, .external_lex_state = 2}, + [2860] = {.lex_state = 0, .external_lex_state = 2}, + [2861] = {.lex_state = 101, .external_lex_state = 2}, + [2862] = {.lex_state = 100, .external_lex_state = 2}, + [2863] = {.lex_state = 0, .external_lex_state = 2}, + [2864] = {.lex_state = 100, .external_lex_state = 2}, + [2865] = {.lex_state = 0, .external_lex_state = 2}, + [2866] = {.lex_state = 0, .external_lex_state = 2}, + [2867] = {.lex_state = 0, .external_lex_state = 2}, + [2868] = {.lex_state = 0, .external_lex_state = 2}, + [2869] = {.lex_state = 0, .external_lex_state = 2}, + [2870] = {.lex_state = 0, .external_lex_state = 2}, + [2871] = {.lex_state = 0, .external_lex_state = 2}, + [2872] = {.lex_state = 0, .external_lex_state = 2}, + [2873] = {.lex_state = 0, .external_lex_state = 2}, + [2874] = {.lex_state = 101, .external_lex_state = 2}, + [2875] = {.lex_state = 0, .external_lex_state = 2}, + [2876] = {.lex_state = 0, .external_lex_state = 2}, + [2877] = {.lex_state = 0, .external_lex_state = 2}, + [2878] = {.lex_state = 0, .external_lex_state = 2}, + [2879] = {.lex_state = 0, .external_lex_state = 2}, + [2880] = {.lex_state = 0, .external_lex_state = 2}, + [2881] = {.lex_state = 0, .external_lex_state = 2}, + [2882] = {.lex_state = 0, .external_lex_state = 2}, + [2883] = {.lex_state = 0, .external_lex_state = 2}, + [2884] = {.lex_state = 0, .external_lex_state = 2}, + [2885] = {.lex_state = 0, .external_lex_state = 2}, + [2886] = {.lex_state = 0, .external_lex_state = 2}, + [2887] = {.lex_state = 0, .external_lex_state = 2}, + [2888] = {.lex_state = 0, .external_lex_state = 2}, + [2889] = {.lex_state = 0, .external_lex_state = 2}, + [2890] = {.lex_state = 0, .external_lex_state = 2}, + [2891] = {.lex_state = 0, .external_lex_state = 2}, + [2892] = {.lex_state = 0, .external_lex_state = 2}, + [2893] = {.lex_state = 54, .external_lex_state = 2}, + [2894] = {.lex_state = 0, .external_lex_state = 2}, + [2895] = {.lex_state = 101, .external_lex_state = 2}, + [2896] = {.lex_state = 0, .external_lex_state = 2}, + [2897] = {.lex_state = 100, .external_lex_state = 2}, + [2898] = {.lex_state = 0, .external_lex_state = 2}, + [2899] = {.lex_state = 100, .external_lex_state = 2}, + [2900] = {.lex_state = 100, .external_lex_state = 2}, + [2901] = {.lex_state = 0, .external_lex_state = 2}, + [2902] = {.lex_state = 100, .external_lex_state = 2}, + [2903] = {.lex_state = 0, .external_lex_state = 2}, + [2904] = {.lex_state = 0, .external_lex_state = 2}, + [2905] = {.lex_state = 101, .external_lex_state = 2}, + [2906] = {.lex_state = 100, .external_lex_state = 2}, + [2907] = {.lex_state = 101, .external_lex_state = 2}, + [2908] = {.lex_state = 101, .external_lex_state = 2}, + [2909] = {.lex_state = 0, .external_lex_state = 2}, + [2910] = {.lex_state = 0, .external_lex_state = 2}, + [2911] = {.lex_state = 0, .external_lex_state = 2}, + [2912] = {.lex_state = 0, .external_lex_state = 2}, + [2913] = {.lex_state = 100, .external_lex_state = 2}, + [2914] = {.lex_state = 100, .external_lex_state = 2}, + [2915] = {.lex_state = 0, .external_lex_state = 2}, + [2916] = {.lex_state = 0, .external_lex_state = 2}, + [2917] = {.lex_state = 0, .external_lex_state = 2}, + [2918] = {.lex_state = 0, .external_lex_state = 2}, + [2919] = {.lex_state = 0, .external_lex_state = 2}, + [2920] = {.lex_state = 0, .external_lex_state = 2}, + [2921] = {.lex_state = 0, .external_lex_state = 2}, + [2922] = {.lex_state = 100, .external_lex_state = 2}, + [2923] = {.lex_state = 0, .external_lex_state = 2}, + [2924] = {.lex_state = 0, .external_lex_state = 2}, + [2925] = {.lex_state = 0, .external_lex_state = 2}, + [2926] = {.lex_state = 0, .external_lex_state = 2}, + [2927] = {.lex_state = 0, .external_lex_state = 2}, + [2928] = {.lex_state = 0, .external_lex_state = 2}, + [2929] = {.lex_state = 0, .external_lex_state = 2}, + [2930] = {.lex_state = 0, .external_lex_state = 2}, + [2931] = {.lex_state = 0, .external_lex_state = 2}, + [2932] = {.lex_state = 0, .external_lex_state = 2}, + [2933] = {.lex_state = 0, .external_lex_state = 2}, + [2934] = {.lex_state = 0, .external_lex_state = 2}, + [2935] = {.lex_state = 0, .external_lex_state = 2}, + [2936] = {.lex_state = 0, .external_lex_state = 2}, + [2937] = {.lex_state = 101, .external_lex_state = 2}, + [2938] = {.lex_state = 0, .external_lex_state = 2}, + [2939] = {.lex_state = 0, .external_lex_state = 2}, + [2940] = {.lex_state = 101, .external_lex_state = 2}, + [2941] = {.lex_state = 100, .external_lex_state = 2}, + [2942] = {.lex_state = 101, .external_lex_state = 2}, + [2943] = {.lex_state = 100, .external_lex_state = 2}, + [2944] = {.lex_state = 0, .external_lex_state = 2}, + [2945] = {.lex_state = 0, .external_lex_state = 2}, + [2946] = {.lex_state = 100, .external_lex_state = 2}, + [2947] = {.lex_state = 101, .external_lex_state = 2}, + [2948] = {.lex_state = 101, .external_lex_state = 2}, + [2949] = {.lex_state = 0, .external_lex_state = 2}, + [2950] = {.lex_state = 100, .external_lex_state = 2}, + [2951] = {.lex_state = 0, .external_lex_state = 2}, + [2952] = {.lex_state = 0, .external_lex_state = 2}, + [2953] = {.lex_state = 0, .external_lex_state = 2}, + [2954] = {.lex_state = 0, .external_lex_state = 2}, + [2955] = {.lex_state = 0, .external_lex_state = 2}, + [2956] = {.lex_state = 101, .external_lex_state = 2}, + [2957] = {.lex_state = 0, .external_lex_state = 2}, + [2958] = {.lex_state = 100, .external_lex_state = 2}, + [2959] = {.lex_state = 100, .external_lex_state = 2}, + [2960] = {.lex_state = 0, .external_lex_state = 2}, + [2961] = {.lex_state = 0, .external_lex_state = 2}, + [2962] = {.lex_state = 100, .external_lex_state = 2}, + [2963] = {.lex_state = 100, .external_lex_state = 2}, + [2964] = {.lex_state = 0, .external_lex_state = 2}, + [2965] = {.lex_state = 0, .external_lex_state = 2}, + [2966] = {.lex_state = 0, .external_lex_state = 2}, + [2967] = {.lex_state = 0, .external_lex_state = 2}, + [2968] = {.lex_state = 100, .external_lex_state = 2}, + [2969] = {.lex_state = 100, .external_lex_state = 2}, + [2970] = {.lex_state = 54, .external_lex_state = 2}, + [2971] = {.lex_state = 0, .external_lex_state = 2}, + [2972] = {.lex_state = 100, .external_lex_state = 2}, + [2973] = {.lex_state = 100, .external_lex_state = 2}, + [2974] = {.lex_state = 0, .external_lex_state = 2}, + [2975] = {.lex_state = 0, .external_lex_state = 2}, + [2976] = {.lex_state = 0, .external_lex_state = 2}, + [2977] = {.lex_state = 101, .external_lex_state = 2}, + [2978] = {.lex_state = 0, .external_lex_state = 2}, + [2979] = {.lex_state = 101, .external_lex_state = 2}, + [2980] = {.lex_state = 101, .external_lex_state = 2}, + [2981] = {.lex_state = 0, .external_lex_state = 2}, + [2982] = {.lex_state = 101, .external_lex_state = 2}, + [2983] = {.lex_state = 0, .external_lex_state = 2}, + [2984] = {.lex_state = 0, .external_lex_state = 2}, + [2985] = {.lex_state = 0, .external_lex_state = 2}, + [2986] = {.lex_state = 0, .external_lex_state = 2}, + [2987] = {.lex_state = 0, .external_lex_state = 2}, + [2988] = {.lex_state = 0, .external_lex_state = 2}, + [2989] = {.lex_state = 0, .external_lex_state = 2}, + [2990] = {.lex_state = 0, .external_lex_state = 2}, + [2991] = {.lex_state = 0, .external_lex_state = 2}, + [2992] = {.lex_state = 0, .external_lex_state = 2}, + [2993] = {.lex_state = 0, .external_lex_state = 2}, + [2994] = {.lex_state = 101, .external_lex_state = 2}, + [2995] = {.lex_state = 0, .external_lex_state = 2}, + [2996] = {.lex_state = 0, .external_lex_state = 2}, + [2997] = {.lex_state = 101, .external_lex_state = 2}, + [2998] = {.lex_state = 0, .external_lex_state = 2}, + [2999] = {.lex_state = 0, .external_lex_state = 2}, + [3000] = {.lex_state = 101, .external_lex_state = 2}, + [3001] = {.lex_state = 0, .external_lex_state = 2}, + [3002] = {.lex_state = 0, .external_lex_state = 2}, + [3003] = {.lex_state = 0, .external_lex_state = 2}, + [3004] = {.lex_state = 0, .external_lex_state = 2}, + [3005] = {.lex_state = 0, .external_lex_state = 2}, + [3006] = {.lex_state = 0, .external_lex_state = 2}, + [3007] = {.lex_state = 0, .external_lex_state = 2}, + [3008] = {.lex_state = 0, .external_lex_state = 2}, + [3009] = {.lex_state = 0, .external_lex_state = 2}, + [3010] = {.lex_state = 0, .external_lex_state = 2}, + [3011] = {.lex_state = 0, .external_lex_state = 2}, + [3012] = {.lex_state = 0, .external_lex_state = 2}, + [3013] = {.lex_state = 101, .external_lex_state = 2}, + [3014] = {.lex_state = 0, .external_lex_state = 2}, + [3015] = {.lex_state = 0, .external_lex_state = 2}, + [3016] = {.lex_state = 0, .external_lex_state = 2}, + [3017] = {.lex_state = 0, .external_lex_state = 2}, + [3018] = {.lex_state = 0, .external_lex_state = 2}, + [3019] = {.lex_state = 0, .external_lex_state = 2}, + [3020] = {.lex_state = 101, .external_lex_state = 2}, + [3021] = {.lex_state = 0, .external_lex_state = 2}, + [3022] = {.lex_state = 0, .external_lex_state = 2}, + [3023] = {.lex_state = 0, .external_lex_state = 2}, + [3024] = {.lex_state = 0, .external_lex_state = 2}, + [3025] = {.lex_state = 0, .external_lex_state = 2}, + [3026] = {.lex_state = 0, .external_lex_state = 2}, + [3027] = {.lex_state = 0, .external_lex_state = 2}, + [3028] = {.lex_state = 0, .external_lex_state = 2}, + [3029] = {.lex_state = 0, .external_lex_state = 2}, + [3030] = {.lex_state = 0, .external_lex_state = 2}, + [3031] = {.lex_state = 0, .external_lex_state = 2}, + [3032] = {.lex_state = 0, .external_lex_state = 2}, + [3033] = {.lex_state = 0, .external_lex_state = 2}, + [3034] = {.lex_state = 0, .external_lex_state = 2}, + [3035] = {.lex_state = 0, .external_lex_state = 2}, + [3036] = {.lex_state = 0, .external_lex_state = 2}, + [3037] = {.lex_state = 0, .external_lex_state = 2}, + [3038] = {.lex_state = 0, .external_lex_state = 2}, + [3039] = {.lex_state = 0, .external_lex_state = 2}, + [3040] = {.lex_state = 101, .external_lex_state = 2}, + [3041] = {.lex_state = 0, .external_lex_state = 2}, + [3042] = {.lex_state = 100, .external_lex_state = 2}, + [3043] = {.lex_state = 100, .external_lex_state = 2}, + [3044] = {.lex_state = 101, .external_lex_state = 2}, + [3045] = {.lex_state = 101, .external_lex_state = 2}, + [3046] = {.lex_state = 0, .external_lex_state = 2}, + [3047] = {.lex_state = 0, .external_lex_state = 2}, + [3048] = {.lex_state = 101, .external_lex_state = 2}, + [3049] = {.lex_state = 0, .external_lex_state = 2}, + [3050] = {.lex_state = 0, .external_lex_state = 2}, + [3051] = {.lex_state = 100, .external_lex_state = 2}, + [3052] = {.lex_state = 0, .external_lex_state = 2}, + [3053] = {.lex_state = 0, .external_lex_state = 2}, + [3054] = {.lex_state = 0, .external_lex_state = 2}, + [3055] = {.lex_state = 100, .external_lex_state = 2}, + [3056] = {.lex_state = 0, .external_lex_state = 2}, + [3057] = {.lex_state = 0, .external_lex_state = 2}, + [3058] = {.lex_state = 0, .external_lex_state = 2}, + [3059] = {.lex_state = 0, .external_lex_state = 2}, + [3060] = {.lex_state = 0, .external_lex_state = 2}, + [3061] = {.lex_state = 0, .external_lex_state = 2}, + [3062] = {.lex_state = 0, .external_lex_state = 2}, + [3063] = {.lex_state = 0, .external_lex_state = 2}, + [3064] = {.lex_state = 101, .external_lex_state = 2}, + [3065] = {.lex_state = 0, .external_lex_state = 2}, + [3066] = {.lex_state = 0, .external_lex_state = 2}, + [3067] = {.lex_state = 0, .external_lex_state = 2}, + [3068] = {.lex_state = 0, .external_lex_state = 2}, + [3069] = {.lex_state = 0, .external_lex_state = 2}, + [3070] = {.lex_state = 0, .external_lex_state = 2}, + [3071] = {.lex_state = 0, .external_lex_state = 2}, + [3072] = {.lex_state = 0, .external_lex_state = 2}, + [3073] = {.lex_state = 0, .external_lex_state = 2}, + [3074] = {.lex_state = 101, .external_lex_state = 2}, + [3075] = {.lex_state = 0, .external_lex_state = 2}, + [3076] = {.lex_state = 0, .external_lex_state = 2}, + [3077] = {.lex_state = 0, .external_lex_state = 2}, + [3078] = {.lex_state = 0, .external_lex_state = 2}, + [3079] = {.lex_state = 0, .external_lex_state = 2}, + [3080] = {.lex_state = 0, .external_lex_state = 2}, + [3081] = {.lex_state = 0, .external_lex_state = 2}, + [3082] = {.lex_state = 101, .external_lex_state = 2}, + [3083] = {.lex_state = 0, .external_lex_state = 2}, + [3084] = {.lex_state = 0, .external_lex_state = 2}, + [3085] = {.lex_state = 0, .external_lex_state = 2}, + [3086] = {.lex_state = 101, .external_lex_state = 2}, + [3087] = {.lex_state = 0, .external_lex_state = 2}, + [3088] = {.lex_state = 0, .external_lex_state = 2}, + [3089] = {.lex_state = 0, .external_lex_state = 2}, + [3090] = {.lex_state = 0, .external_lex_state = 2}, + [3091] = {.lex_state = 0, .external_lex_state = 2}, + [3092] = {.lex_state = 0, .external_lex_state = 2}, + [3093] = {.lex_state = 0, .external_lex_state = 2}, + [3094] = {.lex_state = 0, .external_lex_state = 2}, + [3095] = {.lex_state = 0, .external_lex_state = 2}, + [3096] = {.lex_state = 0, .external_lex_state = 2}, + [3097] = {.lex_state = 101, .external_lex_state = 2}, + [3098] = {.lex_state = 0, .external_lex_state = 2}, + [3099] = {.lex_state = 0, .external_lex_state = 2}, + [3100] = {.lex_state = 0, .external_lex_state = 2}, + [3101] = {.lex_state = 0, .external_lex_state = 2}, + [3102] = {.lex_state = 0, .external_lex_state = 2}, + [3103] = {.lex_state = 0, .external_lex_state = 2}, + [3104] = {.lex_state = 0, .external_lex_state = 2}, + [3105] = {.lex_state = 0, .external_lex_state = 2}, + [3106] = {.lex_state = 0, .external_lex_state = 2}, + [3107] = {.lex_state = 0, .external_lex_state = 2}, + [3108] = {.lex_state = 100, .external_lex_state = 2}, + [3109] = {.lex_state = 0, .external_lex_state = 2}, + [3110] = {.lex_state = 0, .external_lex_state = 2}, + [3111] = {.lex_state = 0, .external_lex_state = 2}, + [3112] = {.lex_state = 0, .external_lex_state = 2}, + [3113] = {.lex_state = 0, .external_lex_state = 2}, + [3114] = {.lex_state = 0, .external_lex_state = 2}, + [3115] = {.lex_state = 0, .external_lex_state = 2}, + [3116] = {.lex_state = 101, .external_lex_state = 2}, + [3117] = {.lex_state = 100, .external_lex_state = 2}, + [3118] = {.lex_state = 101, .external_lex_state = 2}, + [3119] = {.lex_state = 0, .external_lex_state = 2}, + [3120] = {.lex_state = 0, .external_lex_state = 2}, + [3121] = {.lex_state = 0, .external_lex_state = 2}, + [3122] = {.lex_state = 0, .external_lex_state = 2}, + [3123] = {.lex_state = 0, .external_lex_state = 2}, + [3124] = {.lex_state = 101, .external_lex_state = 2}, + [3125] = {.lex_state = 0, .external_lex_state = 2}, + [3126] = {.lex_state = 0, .external_lex_state = 2}, + [3127] = {.lex_state = 0, .external_lex_state = 2}, + [3128] = {.lex_state = 0, .external_lex_state = 2}, + [3129] = {.lex_state = 0, .external_lex_state = 2}, + [3130] = {.lex_state = 0, .external_lex_state = 2}, + [3131] = {.lex_state = 0, .external_lex_state = 2}, + [3132] = {.lex_state = 0, .external_lex_state = 2}, + [3133] = {.lex_state = 0, .external_lex_state = 2}, + [3134] = {.lex_state = 100, .external_lex_state = 2}, + [3135] = {.lex_state = 100, .external_lex_state = 2}, + [3136] = {.lex_state = 0, .external_lex_state = 2}, + [3137] = {.lex_state = 100, .external_lex_state = 2}, + [3138] = {.lex_state = 101, .external_lex_state = 2}, + [3139] = {.lex_state = 0, .external_lex_state = 2}, + [3140] = {.lex_state = 100, .external_lex_state = 2}, + [3141] = {.lex_state = 100, .external_lex_state = 2}, + [3142] = {.lex_state = 101, .external_lex_state = 2}, + [3143] = {.lex_state = 0, .external_lex_state = 2}, + [3144] = {.lex_state = 0, .external_lex_state = 2}, + [3145] = {.lex_state = 0, .external_lex_state = 2}, + [3146] = {.lex_state = 0, .external_lex_state = 2}, + [3147] = {.lex_state = 0, .external_lex_state = 2}, + [3148] = {.lex_state = 0, .external_lex_state = 2}, + [3149] = {.lex_state = 100, .external_lex_state = 2}, + [3150] = {.lex_state = 0, .external_lex_state = 2}, + [3151] = {.lex_state = 0, .external_lex_state = 2}, + [3152] = {.lex_state = 0, .external_lex_state = 2}, + [3153] = {.lex_state = 0, .external_lex_state = 2}, + [3154] = {.lex_state = 0, .external_lex_state = 2}, + [3155] = {.lex_state = 0, .external_lex_state = 2}, + [3156] = {.lex_state = 0, .external_lex_state = 2}, + [3157] = {.lex_state = 0, .external_lex_state = 2}, + [3158] = {.lex_state = 0, .external_lex_state = 2}, + [3159] = {.lex_state = 101, .external_lex_state = 2}, + [3160] = {.lex_state = 0, .external_lex_state = 2}, + [3161] = {.lex_state = 101, .external_lex_state = 2}, + [3162] = {.lex_state = 0, .external_lex_state = 2}, + [3163] = {.lex_state = 101, .external_lex_state = 2}, + [3164] = {.lex_state = 20, .external_lex_state = 2}, + [3165] = {.lex_state = 100, .external_lex_state = 2}, + [3166] = {.lex_state = 101, .external_lex_state = 2}, + [3167] = {.lex_state = 0, .external_lex_state = 2}, + [3168] = {.lex_state = 0, .external_lex_state = 2}, + [3169] = {.lex_state = 0, .external_lex_state = 2}, + [3170] = {.lex_state = 0, .external_lex_state = 2}, + [3171] = {.lex_state = 0, .external_lex_state = 2}, + [3172] = {.lex_state = 0, .external_lex_state = 2}, + [3173] = {.lex_state = 0, .external_lex_state = 2}, + [3174] = {.lex_state = 0, .external_lex_state = 2}, + [3175] = {.lex_state = 0, .external_lex_state = 2}, + [3176] = {.lex_state = 0, .external_lex_state = 2}, + [3177] = {.lex_state = 0, .external_lex_state = 2}, + [3178] = {.lex_state = 101, .external_lex_state = 2}, + [3179] = {.lex_state = 0, .external_lex_state = 2}, + [3180] = {.lex_state = 0, .external_lex_state = 2}, + [3181] = {.lex_state = 0, .external_lex_state = 2}, + [3182] = {.lex_state = 0, .external_lex_state = 2}, + [3183] = {.lex_state = 0, .external_lex_state = 2}, + [3184] = {.lex_state = 0, .external_lex_state = 2}, + [3185] = {.lex_state = 101, .external_lex_state = 2}, + [3186] = {.lex_state = 0, .external_lex_state = 2}, + [3187] = {.lex_state = 102, .external_lex_state = 2}, + [3188] = {.lex_state = 0, .external_lex_state = 2}, + [3189] = {.lex_state = 101, .external_lex_state = 2}, + [3190] = {.lex_state = 0, .external_lex_state = 2}, + [3191] = {.lex_state = 0, .external_lex_state = 2}, + [3192] = {.lex_state = 0, .external_lex_state = 2}, + [3193] = {.lex_state = 101, .external_lex_state = 2}, + [3194] = {.lex_state = 0, .external_lex_state = 2}, + [3195] = {.lex_state = 0, .external_lex_state = 2}, + [3196] = {.lex_state = 0, .external_lex_state = 2}, + [3197] = {.lex_state = 0, .external_lex_state = 2}, + [3198] = {.lex_state = 0, .external_lex_state = 2}, + [3199] = {.lex_state = 0, .external_lex_state = 2}, + [3200] = {.lex_state = 0, .external_lex_state = 2}, + [3201] = {.lex_state = 100, .external_lex_state = 2}, + [3202] = {.lex_state = 0, .external_lex_state = 2}, + [3203] = {.lex_state = 0, .external_lex_state = 2}, + [3204] = {.lex_state = 0, .external_lex_state = 2}, + [3205] = {.lex_state = 101, .external_lex_state = 2}, + [3206] = {.lex_state = 101, .external_lex_state = 2}, + [3207] = {.lex_state = 0, .external_lex_state = 2}, + [3208] = {.lex_state = 0, .external_lex_state = 2}, + [3209] = {.lex_state = 101, .external_lex_state = 2}, + [3210] = {.lex_state = 0, .external_lex_state = 2}, + [3211] = {.lex_state = 0, .external_lex_state = 2}, + [3212] = {.lex_state = 0, .external_lex_state = 2}, + [3213] = {.lex_state = 0, .external_lex_state = 2}, + [3214] = {.lex_state = 0, .external_lex_state = 2}, + [3215] = {.lex_state = 101, .external_lex_state = 2}, + [3216] = {.lex_state = 0, .external_lex_state = 2}, + [3217] = {.lex_state = 0, .external_lex_state = 2}, + [3218] = {.lex_state = 0, .external_lex_state = 2}, + [3219] = {.lex_state = 0, .external_lex_state = 2}, + [3220] = {.lex_state = 0, .external_lex_state = 2}, + [3221] = {.lex_state = 0, .external_lex_state = 2}, + [3222] = {.lex_state = 0, .external_lex_state = 2}, + [3223] = {.lex_state = 0, .external_lex_state = 2}, + [3224] = {.lex_state = 0, .external_lex_state = 2}, + [3225] = {.lex_state = 0, .external_lex_state = 2}, + [3226] = {.lex_state = 0, .external_lex_state = 2}, + [3227] = {.lex_state = 0, .external_lex_state = 2}, + [3228] = {.lex_state = 0, .external_lex_state = 2}, + [3229] = {.lex_state = 101, .external_lex_state = 2}, + [3230] = {.lex_state = 0, .external_lex_state = 2}, + [3231] = {.lex_state = 0, .external_lex_state = 2}, + [3232] = {.lex_state = 101, .external_lex_state = 2}, + [3233] = {.lex_state = 0, .external_lex_state = 2}, + [3234] = {.lex_state = 0, .external_lex_state = 2}, + [3235] = {.lex_state = 0, .external_lex_state = 2}, + [3236] = {.lex_state = 0, .external_lex_state = 2}, + [3237] = {.lex_state = 0, .external_lex_state = 2}, + [3238] = {.lex_state = 0, .external_lex_state = 2}, + [3239] = {.lex_state = 0, .external_lex_state = 2}, + [3240] = {.lex_state = 0, .external_lex_state = 2}, + [3241] = {.lex_state = 0, .external_lex_state = 2}, + [3242] = {.lex_state = 101, .external_lex_state = 2}, + [3243] = {.lex_state = 0, .external_lex_state = 2}, + [3244] = {.lex_state = 0, .external_lex_state = 2}, + [3245] = {.lex_state = 100, .external_lex_state = 2}, + [3246] = {.lex_state = 0, .external_lex_state = 2}, + [3247] = {.lex_state = 101, .external_lex_state = 2}, + [3248] = {.lex_state = 0, .external_lex_state = 2}, + [3249] = {.lex_state = 100, .external_lex_state = 2}, + [3250] = {.lex_state = 101, .external_lex_state = 2}, + [3251] = {.lex_state = 0, .external_lex_state = 2}, + [3252] = {.lex_state = 0, .external_lex_state = 2}, + [3253] = {.lex_state = 0, .external_lex_state = 2}, + [3254] = {.lex_state = 0, .external_lex_state = 2}, + [3255] = {.lex_state = 0, .external_lex_state = 2}, + [3256] = {.lex_state = 0, .external_lex_state = 2}, + [3257] = {.lex_state = 101, .external_lex_state = 2}, + [3258] = {.lex_state = 101, .external_lex_state = 2}, + [3259] = {.lex_state = 0, .external_lex_state = 2}, + [3260] = {.lex_state = 0, .external_lex_state = 2}, + [3261] = {.lex_state = 0, .external_lex_state = 2}, + [3262] = {.lex_state = 101, .external_lex_state = 2}, + [3263] = {.lex_state = 0, .external_lex_state = 2}, + [3264] = {.lex_state = 0, .external_lex_state = 2}, + [3265] = {.lex_state = 0, .external_lex_state = 2}, + [3266] = {.lex_state = 0, .external_lex_state = 2}, + [3267] = {.lex_state = 0, .external_lex_state = 2}, + [3268] = {.lex_state = 0, .external_lex_state = 2}, + [3269] = {.lex_state = 0, .external_lex_state = 2}, + [3270] = {.lex_state = 0, .external_lex_state = 2}, + [3271] = {.lex_state = 0, .external_lex_state = 2}, + [3272] = {.lex_state = 0, .external_lex_state = 2}, + [3273] = {.lex_state = 0, .external_lex_state = 2}, + [3274] = {.lex_state = 101, .external_lex_state = 2}, + [3275] = {.lex_state = 0, .external_lex_state = 2}, + [3276] = {.lex_state = 0, .external_lex_state = 2}, + [3277] = {.lex_state = 101, .external_lex_state = 2}, + [3278] = {.lex_state = 0, .external_lex_state = 2}, + [3279] = {.lex_state = 100, .external_lex_state = 2}, + [3280] = {.lex_state = 0, .external_lex_state = 2}, + [3281] = {.lex_state = 0, .external_lex_state = 2}, + [3282] = {.lex_state = 0, .external_lex_state = 2}, + [3283] = {.lex_state = 0, .external_lex_state = 2}, + [3284] = {.lex_state = 0, .external_lex_state = 2}, + [3285] = {.lex_state = 0, .external_lex_state = 2}, + [3286] = {.lex_state = 0, .external_lex_state = 2}, + [3287] = {.lex_state = 0, .external_lex_state = 2}, + [3288] = {.lex_state = 0, .external_lex_state = 2}, + [3289] = {.lex_state = 101, .external_lex_state = 2}, + [3290] = {.lex_state = 0, .external_lex_state = 2}, + [3291] = {.lex_state = 0, .external_lex_state = 2}, + [3292] = {.lex_state = 0, .external_lex_state = 2}, + [3293] = {.lex_state = 101, .external_lex_state = 2}, + [3294] = {.lex_state = 0, .external_lex_state = 2}, + [3295] = {.lex_state = 101, .external_lex_state = 2}, + [3296] = {.lex_state = 100, .external_lex_state = 2}, + [3297] = {.lex_state = 101, .external_lex_state = 2}, + [3298] = {.lex_state = 101, .external_lex_state = 2}, + [3299] = {.lex_state = 101, .external_lex_state = 2}, + [3300] = {.lex_state = 101, .external_lex_state = 2}, + [3301] = {.lex_state = 0, .external_lex_state = 2}, + [3302] = {.lex_state = 0, .external_lex_state = 2}, + [3303] = {.lex_state = 0, .external_lex_state = 2}, + [3304] = {.lex_state = 0, .external_lex_state = 2}, + [3305] = {.lex_state = 101, .external_lex_state = 2}, + [3306] = {.lex_state = 101, .external_lex_state = 2}, + [3307] = {.lex_state = 100, .external_lex_state = 2}, + [3308] = {.lex_state = 101, .external_lex_state = 2}, + [3309] = {.lex_state = 0, .external_lex_state = 2}, + [3310] = {.lex_state = 0, .external_lex_state = 2}, + [3311] = {.lex_state = 0, .external_lex_state = 2}, + [3312] = {.lex_state = 101, .external_lex_state = 2}, + [3313] = {.lex_state = 0, .external_lex_state = 2}, + [3314] = {.lex_state = 0, .external_lex_state = 2}, + [3315] = {.lex_state = 0, .external_lex_state = 2}, + [3316] = {.lex_state = 0, .external_lex_state = 2}, + [3317] = {.lex_state = 0, .external_lex_state = 2}, + [3318] = {.lex_state = 0, .external_lex_state = 2}, + [3319] = {.lex_state = 0, .external_lex_state = 2}, + [3320] = {.lex_state = 0, .external_lex_state = 2}, + [3321] = {.lex_state = 0, .external_lex_state = 2}, + [3322] = {.lex_state = 0, .external_lex_state = 2}, + [3323] = {.lex_state = 0, .external_lex_state = 2}, + [3324] = {.lex_state = 0, .external_lex_state = 2}, + [3325] = {.lex_state = 100, .external_lex_state = 2}, + [3326] = {.lex_state = 101, .external_lex_state = 2}, + [3327] = {.lex_state = 101, .external_lex_state = 2}, + [3328] = {.lex_state = 101, .external_lex_state = 2}, + [3329] = {.lex_state = 0, .external_lex_state = 2}, + [3330] = {.lex_state = 101, .external_lex_state = 2}, + [3331] = {.lex_state = 0, .external_lex_state = 2}, + [3332] = {.lex_state = 290, .external_lex_state = 2}, + [3333] = {.lex_state = 100, .external_lex_state = 2}, + [3334] = {.lex_state = 101, .external_lex_state = 2}, + [3335] = {.lex_state = 0, .external_lex_state = 2}, + [3336] = {.lex_state = 0, .external_lex_state = 2}, + [3337] = {.lex_state = 101, .external_lex_state = 2}, + [3338] = {.lex_state = 0, .external_lex_state = 2}, + [3339] = {.lex_state = 0, .external_lex_state = 2}, + [3340] = {.lex_state = 0, .external_lex_state = 2}, + [3341] = {.lex_state = 100, .external_lex_state = 2}, + [3342] = {.lex_state = 0, .external_lex_state = 2}, + [3343] = {.lex_state = 101, .external_lex_state = 2}, + [3344] = {.lex_state = 101, .external_lex_state = 2}, + [3345] = {.lex_state = 101, .external_lex_state = 2}, + [3346] = {.lex_state = 0, .external_lex_state = 2}, + [3347] = {.lex_state = 0, .external_lex_state = 2}, + [3348] = {.lex_state = 100, .external_lex_state = 2}, + [3349] = {.lex_state = 101, .external_lex_state = 2}, + [3350] = {.lex_state = 101, .external_lex_state = 2}, + [3351] = {.lex_state = 101, .external_lex_state = 2}, + [3352] = {.lex_state = 100, .external_lex_state = 2}, + [3353] = {.lex_state = 0, .external_lex_state = 2}, + [3354] = {.lex_state = 0, .external_lex_state = 2}, + [3355] = {.lex_state = 101, .external_lex_state = 2}, + [3356] = {.lex_state = 0, .external_lex_state = 2}, + [3357] = {.lex_state = 0, .external_lex_state = 2}, + [3358] = {.lex_state = 0, .external_lex_state = 2}, + [3359] = {.lex_state = 100, .external_lex_state = 2}, + [3360] = {.lex_state = 0, .external_lex_state = 2}, + [3361] = {.lex_state = 0, .external_lex_state = 2}, + [3362] = {.lex_state = 101, .external_lex_state = 2}, + [3363] = {.lex_state = 0, .external_lex_state = 2}, + [3364] = {.lex_state = 0, .external_lex_state = 2}, + [3365] = {.lex_state = 101, .external_lex_state = 2}, + [3366] = {.lex_state = 101, .external_lex_state = 2}, + [3367] = {.lex_state = 0, .external_lex_state = 2}, + [3368] = {.lex_state = 0, .external_lex_state = 2}, + [3369] = {.lex_state = 0, .external_lex_state = 2}, + [3370] = {.lex_state = 0, .external_lex_state = 2}, + [3371] = {.lex_state = 0, .external_lex_state = 2}, + [3372] = {.lex_state = 101, .external_lex_state = 2}, + [3373] = {.lex_state = 101, .external_lex_state = 2}, + [3374] = {.lex_state = 0, .external_lex_state = 2}, + [3375] = {.lex_state = 0, .external_lex_state = 2}, + [3376] = {.lex_state = 0, .external_lex_state = 2}, + [3377] = {.lex_state = 0, .external_lex_state = 2}, + [3378] = {.lex_state = 0, .external_lex_state = 2}, + [3379] = {.lex_state = 0, .external_lex_state = 2}, + [3380] = {.lex_state = 0, .external_lex_state = 2}, + [3381] = {.lex_state = 0, .external_lex_state = 2}, + [3382] = {.lex_state = 0, .external_lex_state = 2}, + [3383] = {.lex_state = 0, .external_lex_state = 2}, + [3384] = {.lex_state = 0, .external_lex_state = 2}, + [3385] = {.lex_state = 0, .external_lex_state = 2}, + [3386] = {.lex_state = 0, .external_lex_state = 2}, + [3387] = {.lex_state = 101, .external_lex_state = 2}, + [3388] = {.lex_state = 0, .external_lex_state = 2}, + [3389] = {.lex_state = 0, .external_lex_state = 2}, + [3390] = {.lex_state = 101, .external_lex_state = 2}, + [3391] = {.lex_state = 0, .external_lex_state = 2}, + [3392] = {.lex_state = 101, .external_lex_state = 2}, + [3393] = {.lex_state = 101, .external_lex_state = 2}, + [3394] = {.lex_state = 101, .external_lex_state = 2}, + [3395] = {.lex_state = 100, .external_lex_state = 2}, + [3396] = {.lex_state = 0, .external_lex_state = 2}, + [3397] = {.lex_state = 0, .external_lex_state = 2}, + [3398] = {.lex_state = 101, .external_lex_state = 2}, + [3399] = {.lex_state = 0, .external_lex_state = 2}, + [3400] = {.lex_state = 100, .external_lex_state = 2}, + [3401] = {.lex_state = 276, .external_lex_state = 2}, + [3402] = {.lex_state = 101, .external_lex_state = 2}, + [3403] = {.lex_state = 101, .external_lex_state = 2}, + [3404] = {.lex_state = 101, .external_lex_state = 2}, + [3405] = {.lex_state = 101, .external_lex_state = 2}, + [3406] = {.lex_state = 101, .external_lex_state = 2}, + [3407] = {.lex_state = 0, .external_lex_state = 2}, + [3408] = {.lex_state = 0, .external_lex_state = 2}, + [3409] = {.lex_state = 0, .external_lex_state = 2}, + [3410] = {.lex_state = 0, .external_lex_state = 2}, + [3411] = {.lex_state = 0, .external_lex_state = 2}, + [3412] = {.lex_state = 0, .external_lex_state = 2}, + [3413] = {.lex_state = 0, .external_lex_state = 2}, + [3414] = {.lex_state = 0, .external_lex_state = 2}, + [3415] = {.lex_state = 0, .external_lex_state = 2}, + [3416] = {.lex_state = 0, .external_lex_state = 2}, + [3417] = {.lex_state = 0, .external_lex_state = 2}, + [3418] = {.lex_state = 0, .external_lex_state = 2}, + [3419] = {.lex_state = 0, .external_lex_state = 2}, + [3420] = {.lex_state = 101, .external_lex_state = 2}, + [3421] = {.lex_state = 101, .external_lex_state = 2}, + [3422] = {.lex_state = 101, .external_lex_state = 2}, + [3423] = {.lex_state = 0, .external_lex_state = 2}, + [3424] = {.lex_state = 0, .external_lex_state = 2}, + [3425] = {.lex_state = 101, .external_lex_state = 2}, + [3426] = {.lex_state = 101, .external_lex_state = 2}, + [3427] = {.lex_state = 101, .external_lex_state = 2}, + [3428] = {.lex_state = 0, .external_lex_state = 2}, + [3429] = {.lex_state = 0, .external_lex_state = 2}, + [3430] = {.lex_state = 0, .external_lex_state = 2}, + [3431] = {.lex_state = 100, .external_lex_state = 2}, + [3432] = {.lex_state = 0, .external_lex_state = 2}, + [3433] = {.lex_state = 0, .external_lex_state = 2}, + [3434] = {.lex_state = 0, .external_lex_state = 2}, + [3435] = {.lex_state = 101, .external_lex_state = 2}, + [3436] = {.lex_state = 101, .external_lex_state = 2}, + [3437] = {.lex_state = 101, .external_lex_state = 2}, + [3438] = {.lex_state = 101, .external_lex_state = 2}, + [3439] = {.lex_state = 101, .external_lex_state = 2}, + [3440] = {.lex_state = 0, .external_lex_state = 2}, + [3441] = {.lex_state = 0, .external_lex_state = 2}, + [3442] = {.lex_state = 0, .external_lex_state = 2}, + [3443] = {.lex_state = 0, .external_lex_state = 2}, + [3444] = {.lex_state = 101, .external_lex_state = 2}, + [3445] = {.lex_state = 101, .external_lex_state = 2}, + [3446] = {.lex_state = 101, .external_lex_state = 2}, + [3447] = {.lex_state = 0, .external_lex_state = 2}, + [3448] = {.lex_state = 0, .external_lex_state = 2}, + [3449] = {.lex_state = 100, .external_lex_state = 2}, + [3450] = {.lex_state = 101, .external_lex_state = 2}, + [3451] = {.lex_state = 101, .external_lex_state = 2}, + [3452] = {.lex_state = 0, .external_lex_state = 2}, + [3453] = {.lex_state = 101, .external_lex_state = 2}, + [3454] = {.lex_state = 101, .external_lex_state = 2}, + [3455] = {.lex_state = 101, .external_lex_state = 2}, + [3456] = {.lex_state = 101, .external_lex_state = 2}, + [3457] = {.lex_state = 0, .external_lex_state = 2}, + [3458] = {.lex_state = 0, .external_lex_state = 2}, + [3459] = {.lex_state = 101, .external_lex_state = 2}, + [3460] = {.lex_state = 101, .external_lex_state = 2}, + [3461] = {.lex_state = 101, .external_lex_state = 2}, + [3462] = {.lex_state = 0, .external_lex_state = 2}, + [3463] = {.lex_state = 0, .external_lex_state = 2}, + [3464] = {.lex_state = 101, .external_lex_state = 2}, + [3465] = {.lex_state = 101, .external_lex_state = 2}, + [3466] = {.lex_state = 0, .external_lex_state = 2}, + [3467] = {.lex_state = 101, .external_lex_state = 2}, + [3468] = {.lex_state = 0, .external_lex_state = 2}, + [3469] = {.lex_state = 0, .external_lex_state = 2}, + [3470] = {.lex_state = 101, .external_lex_state = 2}, + [3471] = {.lex_state = 0, .external_lex_state = 2}, + [3472] = {.lex_state = 100, .external_lex_state = 2}, + [3473] = {.lex_state = 101, .external_lex_state = 2}, + [3474] = {.lex_state = 0, .external_lex_state = 2}, + [3475] = {.lex_state = 101, .external_lex_state = 2}, + [3476] = {.lex_state = 100, .external_lex_state = 2}, + [3477] = {.lex_state = 0, .external_lex_state = 2}, + [3478] = {.lex_state = 0, .external_lex_state = 2}, + [3479] = {.lex_state = 0, .external_lex_state = 2}, + [3480] = {.lex_state = 0, .external_lex_state = 2}, + [3481] = {.lex_state = 0, .external_lex_state = 2}, + [3482] = {.lex_state = 101, .external_lex_state = 2}, + [3483] = {.lex_state = 0, .external_lex_state = 2}, + [3484] = {.lex_state = 101, .external_lex_state = 2}, + [3485] = {.lex_state = 0, .external_lex_state = 2}, + [3486] = {.lex_state = 0, .external_lex_state = 2}, + [3487] = {.lex_state = 101, .external_lex_state = 2}, + [3488] = {.lex_state = 101, .external_lex_state = 2}, + [3489] = {.lex_state = 0, .external_lex_state = 2}, + [3490] = {.lex_state = 0, .external_lex_state = 2}, + [3491] = {.lex_state = 101, .external_lex_state = 2}, + [3492] = {.lex_state = 0, .external_lex_state = 2}, + [3493] = {.lex_state = 0, .external_lex_state = 2}, + [3494] = {.lex_state = 101, .external_lex_state = 2}, + [3495] = {.lex_state = 101, .external_lex_state = 2}, + [3496] = {.lex_state = 101, .external_lex_state = 2}, + [3497] = {.lex_state = 0, .external_lex_state = 2}, + [3498] = {.lex_state = 0, .external_lex_state = 2}, + [3499] = {.lex_state = 101, .external_lex_state = 2}, + [3500] = {.lex_state = 101, .external_lex_state = 2}, + [3501] = {.lex_state = 101, .external_lex_state = 2}, + [3502] = {.lex_state = 101, .external_lex_state = 2}, + [3503] = {.lex_state = 101, .external_lex_state = 2}, + [3504] = {.lex_state = 0, .external_lex_state = 2}, + [3505] = {.lex_state = 0, .external_lex_state = 2}, + [3506] = {.lex_state = 0, .external_lex_state = 2}, + [3507] = {.lex_state = 101, .external_lex_state = 2}, + [3508] = {.lex_state = 0, .external_lex_state = 2}, + [3509] = {.lex_state = 101, .external_lex_state = 2}, + [3510] = {.lex_state = 0, .external_lex_state = 2}, + [3511] = {.lex_state = 0, .external_lex_state = 2}, + [3512] = {.lex_state = 0, .external_lex_state = 2}, + [3513] = {.lex_state = 0, .external_lex_state = 2}, + [3514] = {.lex_state = 0, .external_lex_state = 2}, + [3515] = {.lex_state = 0, .external_lex_state = 2}, + [3516] = {.lex_state = 100, .external_lex_state = 2}, + [3517] = {.lex_state = 0, .external_lex_state = 2}, + [3518] = {.lex_state = 100, .external_lex_state = 2}, + [3519] = {.lex_state = 0, .external_lex_state = 2}, + [3520] = {.lex_state = 0, .external_lex_state = 2}, + [3521] = {.lex_state = 0, .external_lex_state = 2}, + [3522] = {.lex_state = 101, .external_lex_state = 2}, + [3523] = {.lex_state = 0, .external_lex_state = 2}, + [3524] = {.lex_state = 101, .external_lex_state = 2}, + [3525] = {.lex_state = 101, .external_lex_state = 2}, + [3526] = {.lex_state = 0, .external_lex_state = 2}, + [3527] = {.lex_state = 0, .external_lex_state = 2}, + [3528] = {.lex_state = 101, .external_lex_state = 2}, + [3529] = {.lex_state = 100, .external_lex_state = 2}, + [3530] = {.lex_state = 100, .external_lex_state = 2}, + [3531] = {.lex_state = 101, .external_lex_state = 2}, + [3532] = {.lex_state = 0, .external_lex_state = 2}, + [3533] = {.lex_state = 20, .external_lex_state = 2}, + [3534] = {.lex_state = 0, .external_lex_state = 2}, + [3535] = {.lex_state = 101, .external_lex_state = 2}, + [3536] = {.lex_state = 0, .external_lex_state = 2}, + [3537] = {.lex_state = 100, .external_lex_state = 2}, + [3538] = {.lex_state = 0, .external_lex_state = 2}, + [3539] = {.lex_state = 0, .external_lex_state = 2}, + [3540] = {.lex_state = 0, .external_lex_state = 2}, + [3541] = {.lex_state = 100, .external_lex_state = 2}, + [3542] = {.lex_state = 0, .external_lex_state = 2}, + [3543] = {.lex_state = 101, .external_lex_state = 2}, + [3544] = {.lex_state = 0, .external_lex_state = 2}, + [3545] = {.lex_state = 101, .external_lex_state = 2}, + [3546] = {.lex_state = 0, .external_lex_state = 2}, + [3547] = {.lex_state = 101, .external_lex_state = 2}, + [3548] = {.lex_state = 0, .external_lex_state = 2}, + [3549] = {.lex_state = 100, .external_lex_state = 2}, + [3550] = {.lex_state = 100, .external_lex_state = 2}, + [3551] = {.lex_state = 0, .external_lex_state = 2}, + [3552] = {.lex_state = 100, .external_lex_state = 2}, + [3553] = {.lex_state = 101, .external_lex_state = 2}, + [3554] = {.lex_state = 0, .external_lex_state = 2}, + [3555] = {.lex_state = 0, .external_lex_state = 2}, + [3556] = {.lex_state = 0, .external_lex_state = 2}, + [3557] = {.lex_state = 0, .external_lex_state = 2}, + [3558] = {.lex_state = 0, .external_lex_state = 2}, + [3559] = {.lex_state = 0, .external_lex_state = 2}, + [3560] = {.lex_state = 101, .external_lex_state = 2}, + [3561] = {.lex_state = 101, .external_lex_state = 2}, + [3562] = {.lex_state = 0, .external_lex_state = 2}, + [3563] = {.lex_state = 0, .external_lex_state = 2}, + [3564] = {.lex_state = 0, .external_lex_state = 2}, + [3565] = {.lex_state = 101, .external_lex_state = 2}, + [3566] = {.lex_state = 0, .external_lex_state = 2}, + [3567] = {.lex_state = 1, .external_lex_state = 2}, + [3568] = {.lex_state = 0, .external_lex_state = 2}, + [3569] = {.lex_state = 0, .external_lex_state = 2}, + [3570] = {.lex_state = 0, .external_lex_state = 2}, + [3571] = {.lex_state = 101, .external_lex_state = 2}, + [3572] = {.lex_state = 0, .external_lex_state = 2}, + [3573] = {.lex_state = 0, .external_lex_state = 2}, + [3574] = {.lex_state = 0, .external_lex_state = 2}, + [3575] = {.lex_state = 0, .external_lex_state = 2}, + [3576] = {.lex_state = 0, .external_lex_state = 2}, + [3577] = {.lex_state = 0, .external_lex_state = 2}, + [3578] = {.lex_state = 0, .external_lex_state = 2}, + [3579] = {.lex_state = 0, .external_lex_state = 2}, + [3580] = {.lex_state = 0, .external_lex_state = 2}, + [3581] = {.lex_state = 101, .external_lex_state = 2}, + [3582] = {.lex_state = 0, .external_lex_state = 2}, + [3583] = {.lex_state = 0, .external_lex_state = 2}, + [3584] = {.lex_state = 101, .external_lex_state = 2}, + [3585] = {.lex_state = 101, .external_lex_state = 2}, + [3586] = {.lex_state = 0, .external_lex_state = 2}, + [3587] = {.lex_state = 2, .external_lex_state = 2}, + [3588] = {.lex_state = 101, .external_lex_state = 2}, + [3589] = {.lex_state = 0, .external_lex_state = 2}, + [3590] = {.lex_state = 0, .external_lex_state = 2}, + [3591] = {.lex_state = 0, .external_lex_state = 2}, + [3592] = {.lex_state = 100, .external_lex_state = 2}, + [3593] = {.lex_state = 0, .external_lex_state = 2}, + [3594] = {.lex_state = 0, .external_lex_state = 2}, + [3595] = {.lex_state = 0, .external_lex_state = 2}, + [3596] = {.lex_state = 101, .external_lex_state = 2}, + [3597] = {.lex_state = 0, .external_lex_state = 2}, + [3598] = {.lex_state = 101, .external_lex_state = 2}, + [3599] = {.lex_state = 0, .external_lex_state = 2}, + [3600] = {.lex_state = 0, .external_lex_state = 2}, + [3601] = {.lex_state = 0, .external_lex_state = 2}, + [3602] = {.lex_state = 0, .external_lex_state = 2}, + [3603] = {.lex_state = 101, .external_lex_state = 2}, + [3604] = {.lex_state = 101, .external_lex_state = 2}, + [3605] = {.lex_state = 101, .external_lex_state = 2}, + [3606] = {.lex_state = 101, .external_lex_state = 2}, + [3607] = {.lex_state = 0, .external_lex_state = 2}, + [3608] = {.lex_state = 101, .external_lex_state = 2}, + [3609] = {.lex_state = 0, .external_lex_state = 2}, + [3610] = {.lex_state = 0, .external_lex_state = 2}, + [3611] = {.lex_state = 0, .external_lex_state = 2}, + [3612] = {.lex_state = 101, .external_lex_state = 2}, + [3613] = {.lex_state = 0, .external_lex_state = 2}, + [3614] = {.lex_state = 0, .external_lex_state = 2}, + [3615] = {.lex_state = 101, .external_lex_state = 2}, + [3616] = {.lex_state = 0, .external_lex_state = 2}, + [3617] = {.lex_state = 0, .external_lex_state = 2}, + [3618] = {.lex_state = 0, .external_lex_state = 2}, + [3619] = {.lex_state = 101, .external_lex_state = 2}, + [3620] = {.lex_state = 0, .external_lex_state = 2}, + [3621] = {.lex_state = 0, .external_lex_state = 2}, + [3622] = {.lex_state = 0, .external_lex_state = 2}, + [3623] = {.lex_state = 0, .external_lex_state = 2}, + [3624] = {.lex_state = 0, .external_lex_state = 2}, + [3625] = {.lex_state = 101, .external_lex_state = 2}, + [3626] = {.lex_state = 0, .external_lex_state = 2}, + [3627] = {.lex_state = 101, .external_lex_state = 2}, + [3628] = {.lex_state = 0, .external_lex_state = 2}, + [3629] = {.lex_state = 0, .external_lex_state = 2}, + [3630] = {.lex_state = 0, .external_lex_state = 2}, + [3631] = {.lex_state = 0, .external_lex_state = 2}, + [3632] = {.lex_state = 101, .external_lex_state = 2}, + [3633] = {.lex_state = 45, .external_lex_state = 2}, + [3634] = {.lex_state = 0, .external_lex_state = 2}, + [3635] = {(TSStateId)(-1),}, + [3636] = {(TSStateId)(-1),}, + [3637] = {(TSStateId)(-1),}, + [3638] = {(TSStateId)(-1),}, + [3639] = {(TSStateId)(-1),}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [STATE(0)] = { + [sym_comment] = STATE(0), + [sym_documentation_comment] = STATE(0), + [ts_builtin_sym_end] = ACTIONS(1), + [sym_identifier] = ACTIONS(1), + [anon_sym_POUND] = ACTIONS(1), + [sym_decimal_integer_literal] = ACTIONS(1), + [sym_hex_integer_literal] = ACTIONS(1), + [sym_decimal_floating_point_literal] = ACTIONS(1), + [anon_sym_true] = ACTIONS(1), + [anon_sym_false] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [anon_sym_SQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1), + [anon_sym_r_DQUOTE] = ACTIONS(1), + [anon_sym_DOLLAR] = ACTIONS(1), + [anon_sym_r_SQUOTE] = ACTIONS(1), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [sym__unused_escape_sequence] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_null] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_throw] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [anon_sym_PLUS_EQ] = ACTIONS(1), + [anon_sym_DASH_EQ] = ACTIONS(1), + [anon_sym_STAR_EQ] = ACTIONS(1), + [anon_sym_SLASH_EQ] = ACTIONS(1), + [anon_sym_PERCENT_EQ] = ACTIONS(1), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1), + [anon_sym_LT_LT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1), + [anon_sym_AMP_EQ] = ACTIONS(1), + [anon_sym_CARET_EQ] = ACTIONS(1), + [anon_sym_PIPE_EQ] = ACTIONS(1), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1), + [anon_sym_QMARK_QMARK] = ACTIONS(1), + [anon_sym_QMARK] = ACTIONS(1), + [sym_equality_operator] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_LT_EQ] = ACTIONS(1), + [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_PIPE] = ACTIONS(1), + [anon_sym_CARET] = ACTIONS(1), + [anon_sym_AMP] = ACTIONS(1), + [anon_sym_LT_LT] = ACTIONS(1), + [anon_sym_GT_GT] = ACTIONS(1), + [anon_sym_GT_GT_GT] = ACTIONS(1), + [sym__additive_operator] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_PERCENT] = ACTIONS(1), + [anon_sym_TILDE_SLASH] = ACTIONS(1), + [sym_increment_operator] = ACTIONS(1), + [anon_sym_DOT_DOT_DOT] = ACTIONS(1), + [sym_minus_operator] = ACTIONS(1), + [anon_sym_BANG] = ACTIONS(1), + [anon_sym_TILDE] = ACTIONS(1), + [anon_sym_await] = ACTIONS(1), + [anon_sym_is] = ACTIONS(1), + [anon_sym_as] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_DOT_DOT] = ACTIONS(1), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1), + [anon_sym_QMARK_DOT] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [anon_sym_switch] = ACTIONS(1), + [anon_sym_EQ_GT] = ACTIONS(1), + [anon_sym_when] = ACTIONS(1), + [anon_sym_default] = ACTIONS(1), + [anon_sym_do] = ACTIONS(1), + [anon_sym_while] = ACTIONS(1), + [anon_sym_continue] = ACTIONS(1), + [anon_sym_yield] = ACTIONS(1), + [anon_sym_return] = ACTIONS(1), + [anon_sym_on] = ACTIONS(1), + [anon_sym_try] = ACTIONS(1), + [anon_sym_catch] = ACTIONS(1), + [anon_sym_finally] = ACTIONS(1), + [anon_sym_if] = ACTIONS(1), + [anon_sym_case] = ACTIONS(1), + [anon_sym_else] = ACTIONS(1), + [anon_sym_for] = ACTIONS(1), + [anon_sym_in] = ACTIONS(1), + [anon_sym_AT] = ACTIONS(1), + [anon_sym_part] = ACTIONS(1), + [anon_sym_EQ_EQ] = ACTIONS(1), + [anon_sym_show] = ACTIONS(1), + [anon_sym_hide] = ACTIONS(1), + [anon_sym_enum] = ACTIONS(1), + [anon_sym_final] = ACTIONS(1), + [anon_sym_inline] = ACTIONS(1), + [anon_sym_class] = ACTIONS(1), + [anon_sym_extension] = ACTIONS(1), + [anon_sym_type] = ACTIONS(1), + [anon_sym_extends] = ACTIONS(1), + [anon_sym_with] = ACTIONS(1), + [sym_void_type] = ACTIONS(1), + [anon_sym_var] = ACTIONS(1), + [anon_sym_async] = ACTIONS(1), + [anon_sym_async_STAR] = ACTIONS(1), + [anon_sym_sync_STAR] = ACTIONS(1), + [anon_sym_POUND_BANG] = ACTIONS(1), + [anon_sym_library] = ACTIONS(1), + [sym_break_builtin] = ACTIONS(1), + [sym_assert_builtin] = ACTIONS(1), + [sym_rethrow_builtin] = ACTIONS(1), + [sym_part_of_builtin] = ACTIONS(1), + [anon_sym_covariant] = ACTIONS(1), + [anon_sym_deferred] = ACTIONS(1), + [anon_sym_export] = ACTIONS(1), + [anon_sym_factory] = ACTIONS(1), + [anon_sym_Function] = ACTIONS(1), + [anon_sym_get] = ACTIONS(1), + [anon_sym_native] = ACTIONS(1), + [anon_sym_implements] = ACTIONS(1), + [anon_sym_import] = ACTIONS(1), + [anon_sym_interface] = ACTIONS(1), + [anon_sym_base] = ACTIONS(1), + [anon_sym_abstract] = ACTIONS(1), + [anon_sym_sealed] = ACTIONS(1), + [anon_sym_operator] = ACTIONS(1), + [anon_sym_mixin] = ACTIONS(1), + [anon_sym_required] = ACTIONS(1), + [anon_sym_set] = ACTIONS(1), + [anon_sym_static] = ACTIONS(1), + [anon_sym_typedef] = ACTIONS(1), + [anon_sym_new] = ACTIONS(1), + [anon_sym_AMP_AMP] = ACTIONS(1), + [anon_sym_PIPE_PIPE] = ACTIONS(1), + [sym_const_builtin] = ACTIONS(1), + [anon_sym_late] = ACTIONS(1), + [anon_sym_external] = ACTIONS(1), + [anon_sym_this] = ACTIONS(1), + [anon_sym_super] = ACTIONS(1), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__template_chars_double] = ACTIONS(1), + [sym__template_chars_single] = ACTIONS(1), + [sym__template_chars_double_single] = ACTIONS(1), + [sym__template_chars_single_single] = ACTIONS(1), + [sym__template_chars_raw_slash] = ACTIONS(1), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(1)] = { + [sym_program] = STATE(3360), + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(533), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym_script_tag] = STATE(435), + [sym_library_name] = STATE(437), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(1), + [sym_documentation_comment] = STATE(1), + [aux_sym_program_repeat1] = STATE(438), + [aux_sym_program_repeat2] = STATE(456), + [aux_sym_program_repeat3] = STATE(463), + [aux_sym_program_repeat4] = STATE(480), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(13), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_POUND_BANG] = ACTIONS(37), + [anon_sym_library] = ACTIONS(39), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(2)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2582), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(2), + [sym_documentation_comment] = STATE(2), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(18), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_RBRACE] = ACTIONS(101), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(3)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2582), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(3), + [sym_documentation_comment] = STATE(3), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(18), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_RBRACE] = ACTIONS(167), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(4)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2582), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(4), + [sym_documentation_comment] = STATE(4), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(18), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_RBRACE] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(5)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2698), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2486), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(544), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(5), + [sym_documentation_comment] = STATE(5), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(6)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2691), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2486), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(535), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(6), + [sym_documentation_comment] = STATE(6), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(7)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2677), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2486), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(539), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(7), + [sym_documentation_comment] = STATE(7), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(8)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2707), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2486), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(527), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_element] = STATE(2683), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(8), + [sym_documentation_comment] = STATE(8), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(99), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(123), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(139), + [anon_sym_for] = ACTIONS(141), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(9)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(9), + [sym_documentation_comment] = STATE(9), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(13), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(173), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(178), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_default] = ACTIONS(182), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_case] = ACTIONS(182), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(10)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(10), + [sym_documentation_comment] = STATE(10), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(188), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(191), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_default] = ACTIONS(193), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_case] = ACTIONS(193), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(11)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(11), + [sym_documentation_comment] = STATE(11), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(195), + [anon_sym_POUND] = ACTIONS(198), + [sym_decimal_integer_literal] = ACTIONS(201), + [sym_hex_integer_literal] = ACTIONS(204), + [sym_decimal_floating_point_literal] = ACTIONS(201), + [anon_sym_true] = ACTIONS(207), + [anon_sym_false] = ACTIONS(210), + [anon_sym_DQUOTE] = ACTIONS(213), + [anon_sym_SQUOTE] = ACTIONS(216), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(219), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(222), + [anon_sym_r_DQUOTE] = ACTIONS(225), + [anon_sym_r_SQUOTE] = ACTIONS(228), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(231), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(234), + [anon_sym_LBRACE] = ACTIONS(237), + [anon_sym_RBRACE] = ACTIONS(240), + [anon_sym_LBRACK] = ACTIONS(242), + [anon_sym_null] = ACTIONS(245), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_throw] = ACTIONS(251), + [anon_sym_LT] = ACTIONS(254), + [sym_increment_operator] = ACTIONS(257), + [sym_minus_operator] = ACTIONS(260), + [anon_sym_BANG] = ACTIONS(263), + [anon_sym_TILDE] = ACTIONS(266), + [anon_sym_await] = ACTIONS(269), + [anon_sym_switch] = ACTIONS(272), + [anon_sym_default] = ACTIONS(275), + [anon_sym_do] = ACTIONS(277), + [anon_sym_while] = ACTIONS(280), + [anon_sym_continue] = ACTIONS(283), + [anon_sym_yield] = ACTIONS(286), + [anon_sym_return] = ACTIONS(289), + [anon_sym_try] = ACTIONS(292), + [anon_sym_if] = ACTIONS(295), + [anon_sym_case] = ACTIONS(275), + [anon_sym_for] = ACTIONS(298), + [anon_sym_AT] = ACTIONS(301), + [anon_sym_final] = ACTIONS(304), + [sym_void_type] = ACTIONS(307), + [anon_sym_var] = ACTIONS(310), + [sym_break_builtin] = ACTIONS(313), + [sym_assert_builtin] = ACTIONS(316), + [sym_rethrow_builtin] = ACTIONS(319), + [anon_sym_covariant] = ACTIONS(322), + [anon_sym_Function] = ACTIONS(325), + [anon_sym_get] = ACTIONS(328), + [anon_sym_set] = ACTIONS(331), + [anon_sym_new] = ACTIONS(334), + [sym_const_builtin] = ACTIONS(337), + [anon_sym_late] = ACTIONS(340), + [anon_sym_this] = ACTIONS(343), + [anon_sym_super] = ACTIONS(346), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(12)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(12), + [sym_documentation_comment] = STATE(12), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(10), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(349), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(352), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_default] = ACTIONS(354), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_case] = ACTIONS(354), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(13)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(13), + [sym_documentation_comment] = STATE(13), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(349), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(352), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_default] = ACTIONS(354), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_case] = ACTIONS(354), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(14)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2976), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2895), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__var_or_type] = STATE(2948), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(2014), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_formal_parameter] = STATE(2728), + [sym__default_formal_parameter] = STATE(2729), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym_qualified] = STATE(2155), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2023), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1371), + [sym_comment] = STATE(14), + [sym_documentation_comment] = STATE(14), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(356), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(362), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(386), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(15)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2976), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2895), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__var_or_type] = STATE(2948), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(2014), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_formal_parameter] = STATE(2728), + [sym__default_formal_parameter] = STATE(2729), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym_qualified] = STATE(2155), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2023), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1371), + [sym_comment] = STATE(15), + [sym_documentation_comment] = STATE(15), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(356), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(388), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(386), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(16)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(16), + [sym_documentation_comment] = STATE(16), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(28), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(390), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(17)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(17), + [sym_documentation_comment] = STATE(17), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(392), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(18)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(18), + [sym_documentation_comment] = STATE(18), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(394), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(19)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(19), + [sym_documentation_comment] = STATE(19), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(20), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(396), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(20)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(20), + [sym_documentation_comment] = STATE(20), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(398), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(21)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(21), + [sym_documentation_comment] = STATE(21), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(22), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(398), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(22)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(22), + [sym_documentation_comment] = STATE(22), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(400), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(23)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(23), + [sym_documentation_comment] = STATE(23), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(24), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(402), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(24)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(24), + [sym_documentation_comment] = STATE(24), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(404), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(25)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(25), + [sym_documentation_comment] = STATE(25), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(26), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(406), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(26)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(26), + [sym_documentation_comment] = STATE(26), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(408), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(27)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(27), + [sym_documentation_comment] = STATE(27), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(18), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(410), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(28)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(28), + [sym_documentation_comment] = STATE(28), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(11), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(412), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(29)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(553), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(29), + [sym_documentation_comment] = STATE(29), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym_block_repeat1] = STATE(17), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(414), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(30)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3180), + [sym__expression] = STATE(3254), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3181), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym__pattern_field] = STATE(2949), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1078), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2627), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2154), + [sym__var_or_type] = STATE(2948), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(2014), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym_qualified] = STATE(2155), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2023), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(242), + [sym_comment] = STATE(30), + [sym_documentation_comment] = STATE(30), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(416), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(418), + [anon_sym_LBRACK] = ACTIONS(420), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(424), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(386), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(31)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(3604), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(31), + [sym_documentation_comment] = STATE(31), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(32)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(546), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(32), + [sym_documentation_comment] = STATE(32), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(33)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3180), + [sym__expression] = STATE(3254), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3181), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym__pattern_field] = STATE(2949), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2895), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__var_or_type] = STATE(2948), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(2014), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym_qualified] = STATE(2155), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2023), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(242), + [sym_comment] = STATE(33), + [sym_documentation_comment] = STATE(33), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(438), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(440), + [anon_sym_LBRACK] = ACTIONS(420), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(386), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(34)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(539), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(34), + [sym_documentation_comment] = STATE(34), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(35)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(535), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(35), + [sym_documentation_comment] = STATE(35), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(36)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(546), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(36), + [sym_documentation_comment] = STATE(36), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(37)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(535), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(37), + [sym_documentation_comment] = STATE(37), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(38)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(3257), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(38), + [sym_documentation_comment] = STATE(38), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(39)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(526), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(39), + [sym_documentation_comment] = STATE(39), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(40)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(3258), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(40), + [sym_documentation_comment] = STATE(40), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(41)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(531), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(41), + [sym_documentation_comment] = STATE(41), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(428), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(430), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(432), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(434), + [anon_sym_for] = ACTIONS(436), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(42)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(544), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(42), + [sym_documentation_comment] = STATE(42), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(43)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(526), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(43), + [sym_documentation_comment] = STATE(43), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(44)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(527), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(44), + [sym_documentation_comment] = STATE(44), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(45)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(531), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(45), + [sym_documentation_comment] = STATE(45), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(46)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3172), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_lambda_expression] = STATE(521), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym__statement] = STATE(539), + [sym_local_function_declaration] = STATE(528), + [sym_block] = STATE(529), + [sym_expression_statement] = STATE(529), + [sym_assert_statement] = STATE(529), + [sym_assertion] = STATE(3346), + [sym_switch_statement] = STATE(529), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_do_statement] = STATE(529), + [sym_break_statement] = STATE(529), + [sym_continue_statement] = STATE(529), + [sym_yield_statement] = STATE(529), + [sym_yield_each_statement] = STATE(529), + [sym_return_statement] = STATE(529), + [sym_try_statement] = STATE(529), + [sym__try_head] = STATE(467), + [sym_if_statement] = STATE(529), + [sym_while_statement] = STATE(529), + [sym_for_statement] = STATE(529), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1070), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2675), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2585), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1750), + [sym_function_signature] = STATE(2414), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(532), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(1012), + [sym__set] = STATE(1012), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1813), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(46), + [sym_documentation_comment] = STATE(46), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(176), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(180), + [anon_sym_switch] = ACTIONS(125), + [anon_sym_do] = ACTIONS(127), + [anon_sym_while] = ACTIONS(129), + [anon_sym_continue] = ACTIONS(131), + [anon_sym_yield] = ACTIONS(133), + [anon_sym_return] = ACTIONS(135), + [anon_sym_try] = ACTIONS(137), + [anon_sym_if] = ACTIONS(184), + [anon_sym_for] = ACTIONS(186), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_break_builtin] = ACTIONS(147), + [sym_assert_builtin] = ACTIONS(149), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(47)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3282), + [sym__expression] = STATE(3146), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3181), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym__pattern_field] = STATE(2949), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2895), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__var_or_type] = STATE(2948), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(2014), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym_qualified] = STATE(2155), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2023), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(262), + [sym_comment] = STATE(47), + [sym_documentation_comment] = STATE(47), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(438), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(440), + [anon_sym_LBRACK] = ACTIONS(420), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(386), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(48)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(800), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2907), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_named_field] = STATE(2888), + [sym__type_name] = STATE(2037), + [sym_typed_identifier] = STATE(3147), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_formal_parameter] = STATE(2665), + [sym__default_named_parameter] = STATE(2726), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__required] = STATE(983), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1369), + [sym_comment] = STATE(48), + [sym_documentation_comment] = STATE(48), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(444), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(448), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_required] = ACTIONS(450), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(49)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(825), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_formal_parameter] = STATE(2665), + [sym__default_named_parameter] = STATE(2726), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__required] = STATE(983), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1369), + [sym_comment] = STATE(49), + [sym_documentation_comment] = STATE(49), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(444), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(452), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_required] = ACTIONS(450), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(50)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(825), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_formal_parameter] = STATE(2665), + [sym__default_named_parameter] = STATE(2726), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__required] = STATE(983), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1369), + [sym_comment] = STATE(50), + [sym_documentation_comment] = STATE(50), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(444), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(448), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_required] = ACTIONS(450), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(51)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2921), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3012), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(51), + [sym_documentation_comment] = STATE(51), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(456), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(52)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2976), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(52), + [sym_documentation_comment] = STATE(52), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(388), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(53)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2904), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(53), + [sym_documentation_comment] = STATE(53), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(460), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(54)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2779), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3012), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(54), + [sym_documentation_comment] = STATE(54), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(462), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(55)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2779), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3012), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(55), + [sym_documentation_comment] = STATE(55), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(464), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(56)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2976), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(56), + [sym_documentation_comment] = STATE(56), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_RBRACK] = ACTIONS(362), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(372), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(57)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3241), + [sym__expression] = STATE(3158), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(255), + [sym_comment] = STATE(57), + [sym_documentation_comment] = STATE(57), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(466), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(468), + [anon_sym_LBRACK] = ACTIONS(470), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(58)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3282), + [sym__expression] = STATE(3146), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(262), + [sym_comment] = STATE(58), + [sym_documentation_comment] = STATE(58), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(466), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(468), + [anon_sym_LBRACK] = ACTIONS(470), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(59)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3180), + [sym__expression] = STATE(3254), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(242), + [sym_comment] = STATE(59), + [sym_documentation_comment] = STATE(59), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(466), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(468), + [anon_sym_LBRACK] = ACTIONS(470), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(60)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3266), + [sym__expression] = STATE(3087), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1059), + [sym_type_parameters] = STATE(2898), + [sym__declared_identifier] = STATE(2501), + [sym__final_const_var_or_type] = STATE(2604), + [sym__type] = STATE(2942), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(2015), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__normal_formal_parameters] = STATE(3210), + [sym_optional_formal_parameters] = STATE(3448), + [sym__optional_postional_formal_parameters] = STATE(3481), + [sym__named_formal_parameters] = STATE(3481), + [sym_formal_parameter] = STATE(2985), + [sym__normal_formal_parameter] = STATE(2493), + [sym__function_formal_parameter] = STATE(2555), + [sym__simple_formal_parameter] = STATE(2478), + [sym_super_formal_parameter] = STATE(2555), + [sym_constructor_param] = STATE(2555), + [sym__covariant] = STATE(1819), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2009), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(1226), + [sym_super] = STATE(1358), + [sym_label] = STATE(258), + [sym_comment] = STATE(60), + [sym_documentation_comment] = STATE(60), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(466), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(468), + [anon_sym_LBRACK] = ACTIONS(470), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(442), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(61)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2660), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3302), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(61), + [sym_documentation_comment] = STATE(61), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_COMMA] = ACTIONS(472), + [anon_sym_RBRACK] = ACTIONS(472), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_QMARK] = ACTIONS(474), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(62)] = { + [sym__bool_literal] = STATE(1292), + [sym__numeric_literal] = STATE(1292), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(1292), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(1292), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(1292), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2706), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_relational_operator] = STATE(328), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(1294), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3237), + [sym_switch_expression] = STATE(930), + [sym__pattern] = STATE(3169), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2190), + [sym_list_pattern] = STATE(2190), + [sym_map_pattern] = STATE(2190), + [sym_record_pattern] = STATE(2190), + [sym_object_pattern] = STATE(2190), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2154), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(2118), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(62), + [sym_documentation_comment] = STATE(62), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(454), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(358), + [anon_sym_LBRACK] = ACTIONS(360), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(366), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(374), + [anon_sym_BANG] = ACTIONS(376), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(458), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(63)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2640), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym_pattern_variable_declaration] = STATE(3259), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym__for_loop_parts] = STATE(3621), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(1378), + [sym_type_parameters] = STATE(2898), + [sym_initialized_variable_definition] = STATE(3259), + [sym__declared_identifier] = STATE(2605), + [sym__final_const_var_or_type] = STATE(3420), + [sym__type] = STATE(2744), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2037), + [sym__var_or_type] = STATE(2948), + [sym_inferred_type] = STATE(1746), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_local_variable_declaration] = STATE(188), + [sym__covariant] = STATE(1821), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_final_builtin] = STATE(1762), + [sym__late_builtin] = STATE(1945), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(176), + [sym_comment] = STATE(63), + [sym_documentation_comment] = STATE(63), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(476), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_covariant] = ACTIONS(153), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(161), + [anon_sym_late] = ACTIONS(67), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(64)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2036), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3422), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_named_field] = STATE(2888), + [sym__type_name] = STATE(2037), + [sym_typed_identifier] = STATE(3147), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(64), + [sym_documentation_comment] = STATE(64), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(480), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(452), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(65)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2036), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(3422), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_named_field] = STATE(2888), + [sym__type_name] = STATE(2037), + [sym_typed_identifier] = STATE(3147), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(65), + [sym_documentation_comment] = STATE(65), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(480), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(484), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(66)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3180), + [sym__expression] = STATE(3186), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(242), + [sym_comment] = STATE(66), + [sym_documentation_comment] = STATE(66), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(488), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(67)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3180), + [sym__expression] = STATE(3601), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(242), + [sym_comment] = STATE(67), + [sym_documentation_comment] = STATE(67), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(494), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(68)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3282), + [sym__expression] = STATE(3557), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(262), + [sym_comment] = STATE(68), + [sym_documentation_comment] = STATE(68), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(494), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(69)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3266), + [sym__expression] = STATE(3558), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(258), + [sym_comment] = STATE(69), + [sym_documentation_comment] = STATE(69), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(494), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(70)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3241), + [sym__expression] = STATE(3407), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(255), + [sym_comment] = STATE(70), + [sym_documentation_comment] = STATE(70), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(494), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(71)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3477), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym_type_parameters] = STATE(2898), + [sym__type] = STATE(2802), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2037), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(71), + [sym_documentation_comment] = STATE(71), + [aux_sym_string_literal_repeat1] = STATE(478), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(496), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(490), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(107), + [anon_sym_RPAREN] = ACTIONS(492), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_AT] = ACTIONS(143), + [sym_void_type] = ACTIONS(33), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(72)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2772), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3006), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(72), + [sym_documentation_comment] = STATE(72), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(500), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(73)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(73), + [sym_documentation_comment] = STATE(73), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(452), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(74)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2903), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(74), + [sym_documentation_comment] = STATE(74), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(504), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(75)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2772), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3006), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(75), + [sym_documentation_comment] = STATE(75), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(506), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(76)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(76), + [sym_documentation_comment] = STATE(76), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(448), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(77)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2894), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3006), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(77), + [sym_documentation_comment] = STATE(77), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(508), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(115), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(78)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(78), + [sym_documentation_comment] = STATE(78), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(510), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(79)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(79), + [sym_documentation_comment] = STATE(79), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(512), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(80)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(80), + [sym_documentation_comment] = STATE(80), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(514), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(81)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(81), + [sym_documentation_comment] = STATE(81), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(516), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(82)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(82), + [sym_documentation_comment] = STATE(82), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(518), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(83)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(83), + [sym_documentation_comment] = STATE(83), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(520), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(84)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(84), + [sym_documentation_comment] = STATE(84), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(520), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(85)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(85), + [sym_documentation_comment] = STATE(85), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(522), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(86)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2772), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(86), + [sym_documentation_comment] = STATE(86), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(524), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(87)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2934), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(87), + [sym_documentation_comment] = STATE(87), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(524), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(88)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(88), + [sym_documentation_comment] = STATE(88), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(526), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(89)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(89), + [sym_documentation_comment] = STATE(89), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(528), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(90)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2935), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(90), + [sym_documentation_comment] = STATE(90), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(530), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(91)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(91), + [sym_documentation_comment] = STATE(91), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(532), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(92)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(92), + [sym_documentation_comment] = STATE(92), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(534), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(93)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(93), + [sym_documentation_comment] = STATE(93), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(536), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(94)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(94), + [sym_documentation_comment] = STATE(94), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(536), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(95)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2779), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(95), + [sym_documentation_comment] = STATE(95), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(530), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(96)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(96), + [sym_documentation_comment] = STATE(96), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(538), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(97)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(97), + [sym_documentation_comment] = STATE(97), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(540), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(98)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(98), + [sym_documentation_comment] = STATE(98), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(540), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(99)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2781), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(99), + [sym_documentation_comment] = STATE(99), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(542), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(100)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2782), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(100), + [sym_documentation_comment] = STATE(100), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(544), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(101)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(3038), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(101), + [sym_documentation_comment] = STATE(101), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(522), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(102)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(3039), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(102), + [sym_documentation_comment] = STATE(102), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(538), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(103)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2931), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(103), + [sym_documentation_comment] = STATE(103), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(546), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(104)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2976), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(104), + [sym_documentation_comment] = STATE(104), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(548), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(105)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(105), + [sym_documentation_comment] = STATE(105), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(550), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(106)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2798), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(106), + [sym_documentation_comment] = STATE(106), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(552), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(107)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2799), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(107), + [sym_documentation_comment] = STATE(107), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(554), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(108)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2749), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(108), + [sym_documentation_comment] = STATE(108), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(522), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(109)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(109), + [sym_documentation_comment] = STATE(109), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(556), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(110)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(110), + [sym_documentation_comment] = STATE(110), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(558), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(111)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2750), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(111), + [sym_documentation_comment] = STATE(111), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(538), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(112)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2811), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(112), + [sym_documentation_comment] = STATE(112), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(556), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(113)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2812), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(113), + [sym_documentation_comment] = STATE(113), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(558), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(114)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(114), + [sym_documentation_comment] = STATE(114), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(560), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(115)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(115), + [sym_documentation_comment] = STATE(115), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(562), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(116)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(116), + [sym_documentation_comment] = STATE(116), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(564), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(117)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(117), + [sym_documentation_comment] = STATE(117), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(566), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(118)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(118), + [sym_documentation_comment] = STATE(118), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(568), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(119)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(119), + [sym_documentation_comment] = STATE(119), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(570), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(120)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(120), + [sym_documentation_comment] = STATE(120), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(572), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(121)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2856), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(121), + [sym_documentation_comment] = STATE(121), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(574), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(122)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2857), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(122), + [sym_documentation_comment] = STATE(122), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(576), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(123)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2869), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(123), + [sym_documentation_comment] = STATE(123), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(578), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(124)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2870), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(124), + [sym_documentation_comment] = STATE(124), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(580), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(125)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(125), + [sym_documentation_comment] = STATE(125), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(582), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(126)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(126), + [sym_documentation_comment] = STATE(126), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(584), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(127)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2879), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(127), + [sym_documentation_comment] = STATE(127), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(582), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(128)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2880), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(128), + [sym_documentation_comment] = STATE(128), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(584), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(129)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(129), + [sym_documentation_comment] = STATE(129), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(586), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(130)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(130), + [sym_documentation_comment] = STATE(130), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(588), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(131)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(131), + [sym_documentation_comment] = STATE(131), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(590), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(132)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(132), + [sym_documentation_comment] = STATE(132), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(592), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(133)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(133), + [sym_documentation_comment] = STATE(133), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(594), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(134)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(134), + [sym_documentation_comment] = STATE(134), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(596), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(135)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2903), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(135), + [sym_documentation_comment] = STATE(135), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(598), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(136)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2904), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(136), + [sym_documentation_comment] = STATE(136), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(600), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(137)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(137), + [sym_documentation_comment] = STATE(137), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(602), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(138)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2921), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(138), + [sym_documentation_comment] = STATE(138), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(604), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(139)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(139), + [sym_documentation_comment] = STATE(139), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(606), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(140)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(140), + [sym_documentation_comment] = STATE(140), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(608), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(141)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2926), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(141), + [sym_documentation_comment] = STATE(141), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(606), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(142)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2927), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(142), + [sym_documentation_comment] = STATE(142), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(608), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(143)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(143), + [sym_documentation_comment] = STATE(143), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(610), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(144)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(144), + [sym_documentation_comment] = STATE(144), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(612), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(145)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(145), + [sym_documentation_comment] = STATE(145), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(614), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(146)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(146), + [sym_documentation_comment] = STATE(146), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_RBRACK] = ACTIONS(616), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(147)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(147), + [sym_documentation_comment] = STATE(147), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(618), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(148)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(148), + [sym_documentation_comment] = STATE(148), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(620), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(149)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(149), + [sym_documentation_comment] = STATE(149), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(622), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(150)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2753), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(150), + [sym_documentation_comment] = STATE(150), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(151)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2848), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(151), + [sym_documentation_comment] = STATE(151), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(152)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2707), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(152), + [sym_documentation_comment] = STATE(152), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(153)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2677), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(153), + [sym_documentation_comment] = STATE(153), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(154)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2690), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(154), + [sym_documentation_comment] = STATE(154), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(155)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2691), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(155), + [sym_documentation_comment] = STATE(155), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(156)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2910), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(156), + [sym_documentation_comment] = STATE(156), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(157)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2667), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(157), + [sym_documentation_comment] = STATE(157), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(158)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2752), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(158), + [sym_documentation_comment] = STATE(158), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(159)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2698), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(159), + [sym_documentation_comment] = STATE(159), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(160)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_pair] = STATE(2683), + [sym__element] = STATE(2847), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2599), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_spread_element] = STATE(2683), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_if_element] = STATE(2683), + [sym_for_element] = STATE(2683), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(160), + [sym_documentation_comment] = STATE(160), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(171), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(378), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_if] = ACTIONS(382), + [anon_sym_for] = ACTIONS(384), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(161)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3434), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(161), + [sym_documentation_comment] = STATE(161), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(626), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(162)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3519), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(162), + [sym_documentation_comment] = STATE(162), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(628), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(163)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3492), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(163), + [sym_documentation_comment] = STATE(163), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(630), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(164)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3562), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(164), + [sym_documentation_comment] = STATE(164), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(632), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(165)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3356), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(165), + [sym_documentation_comment] = STATE(165), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(634), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(166)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3338), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(166), + [sym_documentation_comment] = STATE(166), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(636), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(167)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3399), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(167), + [sym_documentation_comment] = STATE(167), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(638), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(168)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3423), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(168), + [sym_documentation_comment] = STATE(168), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(640), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(169)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__argument_list] = STATE(3443), + [sym__any_argument] = STATE(2873), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(169), + [sym_documentation_comment] = STATE(169), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(642), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(170)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__any_argument] = STATE(3068), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(170), + [sym_documentation_comment] = STATE(170), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(644), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(171)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__any_argument] = STATE(3068), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(171), + [sym_documentation_comment] = STATE(171), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(646), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(172)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3104), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym__any_argument] = STATE(3068), + [sym_argument] = STATE(3127), + [sym_named_argument] = STATE(3127), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(236), + [sym_comment] = STATE(172), + [sym_documentation_comment] = STATE(172), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(173)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3179), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(173), + [sym_documentation_comment] = STATE(173), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(648), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(174)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(2936), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(174), + [sym_documentation_comment] = STATE(174), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(484), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(175)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3179), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(175), + [sym_documentation_comment] = STATE(175), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(650), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(176)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2583), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(192), + [sym_comment] = STATE(176), + [sym_documentation_comment] = STATE(176), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(652), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(177)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3220), + [sym__expression] = STATE(3223), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(243), + [sym_comment] = STATE(177), + [sym_documentation_comment] = STATE(177), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(654), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(178)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3220), + [sym__expression] = STATE(3223), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(243), + [sym_comment] = STATE(178), + [sym_documentation_comment] = STATE(178), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(656), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(179)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2660), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(179), + [sym_documentation_comment] = STATE(179), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(658), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_COMMA] = ACTIONS(658), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_QMARK] = ACTIONS(474), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(180)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3179), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(180), + [sym_documentation_comment] = STATE(180), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(660), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(181)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3006), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(181), + [sym_documentation_comment] = STATE(181), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_RBRACE] = ACTIONS(662), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(182)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3220), + [sym__expression] = STATE(3223), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(243), + [sym_comment] = STATE(182), + [sym_documentation_comment] = STATE(182), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(664), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(183)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3220), + [sym__expression] = STATE(3223), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(243), + [sym_comment] = STATE(183), + [sym_documentation_comment] = STATE(183), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(666), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(184)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2597), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(200), + [sym_comment] = STATE(184), + [sym_documentation_comment] = STATE(184), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(668), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(185)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_record_field] = STATE(3220), + [sym__expression] = STATE(3223), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_label] = STATE(243), + [sym_comment] = STATE(185), + [sym_documentation_comment] = STATE(185), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(624), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(186)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3103), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(538), + [sym_comment] = STATE(186), + [sym_documentation_comment] = STATE(186), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(187)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3564), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym__map_pattern_entry] = STATE(3179), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(187), + [sym_documentation_comment] = STATE(187), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [anon_sym_DOT_DOT_DOT] = ACTIONS(486), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(188)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3291), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(196), + [sym_comment] = STATE(188), + [sym_documentation_comment] = STATE(188), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(189)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3114), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym__semicolon] = STATE(199), + [sym_comment] = STATE(189), + [sym_documentation_comment] = STATE(189), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_SEMI] = ACTIONS(478), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(190)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2966), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(190), + [sym_documentation_comment] = STATE(190), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(670), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(191)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3003), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(191), + [sym_documentation_comment] = STATE(191), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(672), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(192)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2801), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(192), + [sym_documentation_comment] = STATE(192), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(674), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(193)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2875), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(193), + [sym_documentation_comment] = STATE(193), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(676), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(194)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2883), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(194), + [sym_documentation_comment] = STATE(194), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(678), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(195)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3221), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(195), + [sym_documentation_comment] = STATE(195), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(680), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(196)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2793), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(196), + [sym_documentation_comment] = STATE(196), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(682), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(197)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3089), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(197), + [sym_documentation_comment] = STATE(197), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_STAR] = ACTIONS(684), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(198)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2660), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(198), + [sym_documentation_comment] = STATE(198), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_QMARK] = ACTIONS(474), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(199)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2971), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(199), + [sym_documentation_comment] = STATE(199), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(686), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(200)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2872), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(200), + [sym_documentation_comment] = STATE(200), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_RPAREN] = ACTIONS(688), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(201)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3250), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(201), + [sym_documentation_comment] = STATE(201), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(202)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3626), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(202), + [sym_documentation_comment] = STATE(202), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(203)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3123), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(203), + [sym_documentation_comment] = STATE(203), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(204)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1005), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(204), + [sym_documentation_comment] = STATE(204), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(205)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3466), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(205), + [sym_documentation_comment] = STATE(205), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(206)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1001), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(206), + [sym_documentation_comment] = STATE(206), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(207)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(915), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(207), + [sym_documentation_comment] = STATE(207), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(208)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3041), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(208), + [sym_documentation_comment] = STATE(208), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(209)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(959), + [sym__real_expression] = STATE(482), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1959), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3449), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(209), + [sym_documentation_comment] = STATE(209), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(690), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(210)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3174), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(210), + [sym_documentation_comment] = STATE(210), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(211)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3188), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(211), + [sym_documentation_comment] = STATE(211), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(212)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2669), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(212), + [sym_documentation_comment] = STATE(212), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(213)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3142), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(213), + [sym_documentation_comment] = STATE(213), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(214)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression] = STATE(1149), + [sym__real_expression] = STATE(511), + [sym_throw_expression] = STATE(1137), + [sym_rethrow_expression] = STATE(1137), + [sym_assignment_expression] = STATE(1137), + [sym_assignable_expression] = STATE(1958), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3263), + [sym_switch_expression] = STATE(1134), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3348), + [sym_pattern_assignment] = STATE(1137), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2657), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(214), + [sym_documentation_comment] = STATE(214), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(698), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(726), + [anon_sym_LBRACK] = ACTIONS(728), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(732), + [anon_sym_throw] = ACTIONS(734), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [sym_rethrow_builtin] = ACTIONS(744), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(215)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3185), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(215), + [sym_documentation_comment] = STATE(215), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(216)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1005), + [sym__real_expression] = STATE(482), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1959), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3449), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(216), + [sym_documentation_comment] = STATE(216), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(690), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(217)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(915), + [sym__real_expression] = STATE(482), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1959), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3449), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(217), + [sym_documentation_comment] = STATE(217), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(690), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(218)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2441), + [sym__real_expression] = STATE(722), + [sym_throw_expression] = STATE(2463), + [sym_rethrow_expression] = STATE(2463), + [sym_assignment_expression] = STATE(2463), + [sym_assignable_expression] = STATE(1977), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3592), + [sym_pattern_assignment] = STATE(2463), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(218), + [sym_documentation_comment] = STATE(218), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(754), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(756), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(219)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3080), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(219), + [sym_documentation_comment] = STATE(219), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(220)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2377), + [sym__real_expression] = STATE(722), + [sym_throw_expression] = STATE(2463), + [sym_rethrow_expression] = STATE(2463), + [sym_assignment_expression] = STATE(2463), + [sym_assignable_expression] = STATE(1977), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3592), + [sym_pattern_assignment] = STATE(2463), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(220), + [sym_documentation_comment] = STATE(220), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(754), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(756), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(221)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2426), + [sym__real_expression] = STATE(722), + [sym_throw_expression] = STATE(2463), + [sym_rethrow_expression] = STATE(2463), + [sym_assignment_expression] = STATE(2463), + [sym_assignable_expression] = STATE(1977), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3592), + [sym_pattern_assignment] = STATE(2463), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(221), + [sym_documentation_comment] = STATE(221), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(754), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(756), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(222)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2434), + [sym__real_expression] = STATE(722), + [sym_throw_expression] = STATE(2463), + [sym_rethrow_expression] = STATE(2463), + [sym_assignment_expression] = STATE(2463), + [sym_assignable_expression] = STATE(1977), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3592), + [sym_pattern_assignment] = STATE(2463), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(222), + [sym_documentation_comment] = STATE(222), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(754), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(756), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(223)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1265), + [sym__real_expression] = STATE(514), + [sym_throw_expression] = STATE(1307), + [sym_rethrow_expression] = STATE(1307), + [sym_assignment_expression] = STATE(1307), + [sym_assignable_expression] = STATE(1984), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3476), + [sym_pattern_assignment] = STATE(1307), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(223), + [sym_documentation_comment] = STATE(223), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(758), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(760), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(224)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1306), + [sym__real_expression] = STATE(514), + [sym_throw_expression] = STATE(1307), + [sym_rethrow_expression] = STATE(1307), + [sym_assignment_expression] = STATE(1307), + [sym_assignable_expression] = STATE(1984), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3476), + [sym_pattern_assignment] = STATE(1307), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(224), + [sym_documentation_comment] = STATE(224), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(758), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(760), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(225)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1289), + [sym__real_expression] = STATE(514), + [sym_throw_expression] = STATE(1307), + [sym_rethrow_expression] = STATE(1307), + [sym_assignment_expression] = STATE(1307), + [sym_assignable_expression] = STATE(1984), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3476), + [sym_pattern_assignment] = STATE(1307), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(225), + [sym_documentation_comment] = STATE(225), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(758), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(760), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(226)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1246), + [sym__real_expression] = STATE(514), + [sym_throw_expression] = STATE(1307), + [sym_rethrow_expression] = STATE(1307), + [sym_assignment_expression] = STATE(1307), + [sym_assignable_expression] = STATE(1984), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3476), + [sym_pattern_assignment] = STATE(1307), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(226), + [sym_documentation_comment] = STATE(226), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(758), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(760), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(227)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression] = STATE(1180), + [sym__real_expression] = STATE(511), + [sym_throw_expression] = STATE(1137), + [sym_rethrow_expression] = STATE(1137), + [sym_assignment_expression] = STATE(1137), + [sym_assignable_expression] = STATE(1958), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3263), + [sym_switch_expression] = STATE(1134), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3348), + [sym_pattern_assignment] = STATE(1137), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2657), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(227), + [sym_documentation_comment] = STATE(227), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(698), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(726), + [anon_sym_LBRACK] = ACTIONS(728), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(732), + [anon_sym_throw] = ACTIONS(734), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [sym_rethrow_builtin] = ACTIONS(744), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(228)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression] = STATE(1188), + [sym__real_expression] = STATE(511), + [sym_throw_expression] = STATE(1137), + [sym_rethrow_expression] = STATE(1137), + [sym_assignment_expression] = STATE(1137), + [sym_assignable_expression] = STATE(1958), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3263), + [sym_switch_expression] = STATE(1134), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3348), + [sym_pattern_assignment] = STATE(1137), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2657), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(228), + [sym_documentation_comment] = STATE(228), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(698), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(726), + [anon_sym_LBRACK] = ACTIONS(728), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(732), + [anon_sym_throw] = ACTIONS(734), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [sym_rethrow_builtin] = ACTIONS(744), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(229)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression] = STATE(1170), + [sym__real_expression] = STATE(511), + [sym_throw_expression] = STATE(1137), + [sym_rethrow_expression] = STATE(1137), + [sym_assignment_expression] = STATE(1137), + [sym_assignable_expression] = STATE(1958), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3263), + [sym_switch_expression] = STATE(1134), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3348), + [sym_pattern_assignment] = STATE(1137), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2657), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(229), + [sym_documentation_comment] = STATE(229), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(698), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(726), + [anon_sym_LBRACK] = ACTIONS(728), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(732), + [anon_sym_throw] = ACTIONS(734), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [sym_rethrow_builtin] = ACTIONS(744), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(230)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression] = STATE(1178), + [sym__real_expression] = STATE(511), + [sym_throw_expression] = STATE(1137), + [sym_rethrow_expression] = STATE(1137), + [sym_assignment_expression] = STATE(1137), + [sym_assignable_expression] = STATE(1958), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3263), + [sym_switch_expression] = STATE(1134), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3348), + [sym_pattern_assignment] = STATE(1137), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2657), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(230), + [sym_documentation_comment] = STATE(230), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(698), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(726), + [anon_sym_LBRACK] = ACTIONS(728), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(732), + [anon_sym_throw] = ACTIONS(734), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [sym_rethrow_builtin] = ACTIONS(744), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(231)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3233), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(231), + [sym_documentation_comment] = STATE(231), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(232)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2706), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(232), + [sym_documentation_comment] = STATE(232), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(233)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1001), + [sym__real_expression] = STATE(482), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1959), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3449), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(233), + [sym_documentation_comment] = STATE(233), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(690), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(234)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3251), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(234), + [sym_documentation_comment] = STATE(234), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(235)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3523), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(235), + [sym_documentation_comment] = STATE(235), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(236)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3070), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(236), + [sym_documentation_comment] = STATE(236), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(237)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3497), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(237), + [sym_documentation_comment] = STATE(237), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(238)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3631), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(238), + [sym_documentation_comment] = STATE(238), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(239)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(924), + [sym__real_expression] = STATE(482), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1959), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3449), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(239), + [sym_documentation_comment] = STATE(239), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(690), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(240)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3130), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(240), + [sym_documentation_comment] = STATE(240), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(241)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2431), + [sym__real_expression] = STATE(722), + [sym_throw_expression] = STATE(2463), + [sym_rethrow_expression] = STATE(2463), + [sym_assignment_expression] = STATE(2463), + [sym_assignable_expression] = STATE(1977), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3592), + [sym_pattern_assignment] = STATE(2463), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(241), + [sym_documentation_comment] = STATE(241), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(754), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(756), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(242)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3276), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(242), + [sym_documentation_comment] = STATE(242), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(243)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3075), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(243), + [sym_documentation_comment] = STATE(243), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(244)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3368), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(244), + [sym_documentation_comment] = STATE(244), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(245)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3595), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(245), + [sym_documentation_comment] = STATE(245), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(246)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3173), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(246), + [sym_documentation_comment] = STATE(246), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(247)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3275), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(247), + [sym_documentation_comment] = STATE(247), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(248)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3335), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(248), + [sym_documentation_comment] = STATE(248), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(249)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(1252), + [sym__real_expression] = STATE(514), + [sym_throw_expression] = STATE(1307), + [sym_rethrow_expression] = STATE(1307), + [sym_assignment_expression] = STATE(1307), + [sym_assignable_expression] = STATE(1984), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3476), + [sym_pattern_assignment] = STATE(1307), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(249), + [sym_documentation_comment] = STATE(249), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(758), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(760), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(250)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3300), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(250), + [sym_documentation_comment] = STATE(250), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(251)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3096), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(251), + [sym_documentation_comment] = STATE(251), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(252)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3316), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(252), + [sym_documentation_comment] = STATE(252), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(253)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3126), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(253), + [sym_documentation_comment] = STATE(253), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(254)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3367), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(254), + [sym_documentation_comment] = STATE(254), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(255)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3211), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(255), + [sym_documentation_comment] = STATE(255), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(256)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3441), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(256), + [sym_documentation_comment] = STATE(256), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(257)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3521), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(257), + [sym_documentation_comment] = STATE(257), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(258)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3106), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(258), + [sym_documentation_comment] = STATE(258), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(259)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3088), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(259), + [sym_documentation_comment] = STATE(259), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(260)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3600), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(260), + [sym_documentation_comment] = STATE(260), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(261)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3538), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(261), + [sym_documentation_comment] = STATE(261), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(262)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3162), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(262), + [sym_documentation_comment] = STATE(262), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(263)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(2858), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(263), + [sym_documentation_comment] = STATE(263), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(264)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3574), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(264), + [sym_documentation_comment] = STATE(264), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(265)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3376), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(265), + [sym_documentation_comment] = STATE(265), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(266)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3411), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(266), + [sym_documentation_comment] = STATE(266), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(267)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3430), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(267), + [sym_documentation_comment] = STATE(267), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(268)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3440), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(268), + [sym_documentation_comment] = STATE(268), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(269)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3447), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(269), + [sym_documentation_comment] = STATE(269), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(270)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3452), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(270), + [sym_documentation_comment] = STATE(270), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(271)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3457), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(271), + [sym_documentation_comment] = STATE(271), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(272)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3462), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(272), + [sym_documentation_comment] = STATE(272), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(273)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression] = STATE(3486), + [sym__real_expression] = STATE(674), + [sym_throw_expression] = STATE(943), + [sym_rethrow_expression] = STATE(943), + [sym_assignment_expression] = STATE(943), + [sym_assignable_expression] = STATE(1969), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3143), + [sym_switch_expression] = STATE(930), + [sym__parenthesized_pattern] = STATE(3229), + [sym_list_pattern] = STATE(3229), + [sym_map_pattern] = STATE(3229), + [sym_record_pattern] = STATE(3229), + [sym_object_pattern] = STATE(3229), + [sym__outer_pattern] = STATE(3529), + [sym_pattern_assignment] = STATE(943), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2695), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(273), + [sym_documentation_comment] = STATE(273), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(498), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(446), + [anon_sym_LBRACK] = ACTIONS(103), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(502), + [anon_sym_throw] = ACTIONS(109), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [sym_rethrow_builtin] = ACTIONS(151), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(274)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1128), + [sym__real_expression] = STATE(564), + [sym_throw_expression_without_cascade] = STATE(1145), + [sym_assignment_expression_without_cascade] = STATE(1145), + [sym_assignable_expression] = STATE(1964), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(274), + [sym_documentation_comment] = STATE(274), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(770), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(275)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(1482), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(275), + [sym_documentation_comment] = STATE(275), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(276)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(952), + [sym__real_expression] = STATE(702), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1983), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(276), + [sym_documentation_comment] = STATE(276), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(834), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(277)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1994), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1963), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(277), + [sym_documentation_comment] = STATE(277), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(836), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(278)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(904), + [sym__real_expression] = STATE(499), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1974), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(278), + [sym_documentation_comment] = STATE(278), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(844), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(279)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1986), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1963), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(279), + [sym_documentation_comment] = STATE(279), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(836), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(280)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1985), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1957), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(280), + [sym_documentation_comment] = STATE(280), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(846), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(281)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1150), + [sym__real_expression] = STATE(564), + [sym_throw_expression_without_cascade] = STATE(1145), + [sym_assignment_expression_without_cascade] = STATE(1145), + [sym_assignable_expression] = STATE(1964), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(281), + [sym_documentation_comment] = STATE(281), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(770), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(282)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1152), + [sym__real_expression] = STATE(564), + [sym_throw_expression_without_cascade] = STATE(1145), + [sym_assignment_expression_without_cascade] = STATE(1145), + [sym_assignable_expression] = STATE(1964), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(282), + [sym_documentation_comment] = STATE(282), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(770), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(283)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3480), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(283), + [sym_documentation_comment] = STATE(283), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(284)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1002), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1982), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(284), + [sym_documentation_comment] = STATE(284), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(848), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(285)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(904), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1982), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(285), + [sym_documentation_comment] = STATE(285), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(848), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(286)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3428), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(286), + [sym_documentation_comment] = STATE(286), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(287)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(905), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1982), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(287), + [sym_documentation_comment] = STATE(287), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(848), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(288)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1111), + [sym__real_expression] = STATE(564), + [sym_throw_expression_without_cascade] = STATE(1145), + [sym_assignment_expression_without_cascade] = STATE(1145), + [sym_assignable_expression] = STATE(1964), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(691), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1366), + [sym_comment] = STATE(288), + [sym_documentation_comment] = STATE(288), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(770), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(289)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(952), + [sym__real_expression] = STATE(499), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1974), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(289), + [sym_documentation_comment] = STATE(289), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(844), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(290)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1473), + [sym__real_expression] = STATE(702), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1983), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(290), + [sym_documentation_comment] = STATE(290), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(834), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(291)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3575), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(291), + [sym_documentation_comment] = STATE(291), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(292)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1985), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1963), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(292), + [sym_documentation_comment] = STATE(292), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(836), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(293)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1486), + [sym__real_expression] = STATE(702), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1983), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(293), + [sym_documentation_comment] = STATE(293), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(834), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(294)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(1709), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1679), + [sym_assignment_expression_without_cascade] = STATE(1679), + [sym_assignable_expression] = STATE(1965), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(294), + [sym_documentation_comment] = STATE(294), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(850), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(295)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1579), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1615), + [sym_assignment_expression_without_cascade] = STATE(1615), + [sym_assignable_expression] = STATE(1961), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(295), + [sym_documentation_comment] = STATE(295), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(852), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(296)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3566), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(296), + [sym_documentation_comment] = STATE(296), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(297)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1583), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1615), + [sym_assignment_expression_without_cascade] = STATE(1615), + [sym_assignable_expression] = STATE(1961), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(297), + [sym_documentation_comment] = STATE(297), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(852), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(298)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3374), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(298), + [sym_documentation_comment] = STATE(298), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(299)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1482), + [sym__real_expression] = STATE(702), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1983), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(671), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1348), + [sym_comment] = STATE(299), + [sym_documentation_comment] = STATE(299), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(834), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(300)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(3409), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(300), + [sym_documentation_comment] = STATE(300), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(301)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1002), + [sym__real_expression] = STATE(499), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1974), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(301), + [sym_documentation_comment] = STATE(301), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(844), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(302)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__expression_without_cascade] = STATE(1602), + [sym__real_expression] = STATE(721), + [sym_throw_expression_without_cascade] = STATE(1615), + [sym_assignment_expression_without_cascade] = STATE(1615), + [sym_assignable_expression] = STATE(1961), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(689), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(699), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1367), + [sym_comment] = STATE(302), + [sym_documentation_comment] = STATE(302), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(762), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_throw] = ACTIONS(852), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(303)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1994), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1957), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(303), + [sym_documentation_comment] = STATE(303), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(846), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(304)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(1986), + [sym__real_expression] = STATE(774), + [sym_throw_expression_without_cascade] = STATE(1992), + [sym_assignment_expression_without_cascade] = STATE(1992), + [sym_assignable_expression] = STATE(1957), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1362), + [sym_comment] = STATE(304), + [sym_documentation_comment] = STATE(304), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(846), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(305)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(1486), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1503), + [sym_assignment_expression_without_cascade] = STATE(1503), + [sym_assignable_expression] = STATE(1954), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(305), + [sym_documentation_comment] = STATE(305), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(808), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(306)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(1711), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1679), + [sym_assignment_expression_without_cascade] = STATE(1679), + [sym_assignable_expression] = STATE(1965), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(306), + [sym_documentation_comment] = STATE(306), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(850), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(307)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__expression_without_cascade] = STATE(1712), + [sym__real_expression] = STATE(764), + [sym_throw_expression_without_cascade] = STATE(1679), + [sym_assignment_expression_without_cascade] = STATE(1679), + [sym_assignable_expression] = STATE(1965), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(716), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(717), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1355), + [sym_comment] = STATE(307), + [sym_documentation_comment] = STATE(307), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(772), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_throw] = ACTIONS(850), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(308)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__expression_without_cascade] = STATE(905), + [sym__real_expression] = STATE(499), + [sym_throw_expression_without_cascade] = STATE(941), + [sym_assignment_expression_without_cascade] = STATE(941), + [sym_assignable_expression] = STATE(1974), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(646), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(643), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1360), + [sym_comment] = STATE(308), + [sym_documentation_comment] = STATE(308), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(826), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_throw] = ACTIONS(844), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(309)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(692), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(309), + [sym_documentation_comment] = STATE(309), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(310)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(754), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(310), + [sym_documentation_comment] = STATE(310), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(311)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(755), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(311), + [sym_documentation_comment] = STATE(311), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(312)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(783), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(312), + [sym_documentation_comment] = STATE(312), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(313)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(688), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(313), + [sym_documentation_comment] = STATE(313), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(314)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(695), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(314), + [sym_documentation_comment] = STATE(314), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(315)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(805), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(315), + [sym_documentation_comment] = STATE(315), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(316)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(772), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(316), + [sym_documentation_comment] = STATE(316), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(317)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(775), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(317), + [sym_documentation_comment] = STATE(317), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(318)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(752), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(318), + [sym_documentation_comment] = STATE(318), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(319)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(776), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(319), + [sym_documentation_comment] = STATE(319), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(320)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(777), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(320), + [sym_documentation_comment] = STATE(320), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(321)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(778), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(321), + [sym_documentation_comment] = STATE(321), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(322)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(779), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(322), + [sym_documentation_comment] = STATE(322), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(323)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(780), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(323), + [sym_documentation_comment] = STATE(323), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(324)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(781), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(324), + [sym_documentation_comment] = STATE(324), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(325)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(782), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(1349), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1365), + [sym_comment] = STATE(325), + [sym_documentation_comment] = STATE(325), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(326)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(807), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(326), + [sym_documentation_comment] = STATE(326), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(327)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(504), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(327), + [sym_documentation_comment] = STATE(327), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(328)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(760), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(328), + [sym_documentation_comment] = STATE(328), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(329)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(500), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(329), + [sym_documentation_comment] = STATE(329), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(330)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(502), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(330), + [sym_documentation_comment] = STATE(330), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(331)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(503), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(331), + [sym_documentation_comment] = STATE(331), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(332)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(505), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(332), + [sym_documentation_comment] = STATE(332), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(333)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(506), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(333), + [sym_documentation_comment] = STATE(333), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(334)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(501), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(334), + [sym_documentation_comment] = STATE(334), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(335)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(498), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(335), + [sym_documentation_comment] = STATE(335), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(336)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(496), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(336), + [sym_documentation_comment] = STATE(336), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(337)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(497), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(903), + [sym_conditional_expression] = STATE(903), + [sym_logical_or_expression] = STATE(903), + [sym_logical_and_expression] = STATE(903), + [sym_equality_expression] = STATE(903), + [sym_type_cast_expression] = STATE(903), + [sym_type_test_expression] = STATE(903), + [sym_relational_expression] = STATE(903), + [sym_bitwise_or_expression] = STATE(903), + [sym_bitwise_xor_expression] = STATE(903), + [sym_bitwise_and_expression] = STATE(903), + [sym_shift_expression] = STATE(903), + [sym_additive_expression] = STATE(903), + [sym_multiplicative_expression] = STATE(903), + [sym__unary_expression] = STATE(786), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1363), + [sym_comment] = STATE(337), + [sym_documentation_comment] = STATE(337), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(338)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(697), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(338), + [sym_documentation_comment] = STATE(338), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(339)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(686), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(339), + [sym_documentation_comment] = STATE(339), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(340)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(700), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(340), + [sym_documentation_comment] = STATE(340), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(341)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(720), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(341), + [sym_documentation_comment] = STATE(341), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(342)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(725), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(342), + [sym_documentation_comment] = STATE(342), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(343)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(687), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(343), + [sym_documentation_comment] = STATE(343), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(344)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(715), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(344), + [sym_documentation_comment] = STATE(344), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(345)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(713), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(345), + [sym_documentation_comment] = STATE(345), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(346)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(719), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(346), + [sym_documentation_comment] = STATE(346), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(347)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(696), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(347), + [sym_documentation_comment] = STATE(347), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(348)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(728), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(348), + [sym_documentation_comment] = STATE(348), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(349)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(703), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(349), + [sym_documentation_comment] = STATE(349), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(350)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(704), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(350), + [sym_documentation_comment] = STATE(350), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(351)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(714), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(351), + [sym_documentation_comment] = STATE(351), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(352)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(718), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(352), + [sym_documentation_comment] = STATE(352), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(353)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(693), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(353), + [sym_documentation_comment] = STATE(353), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(354)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(723), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(354), + [sym_documentation_comment] = STATE(354), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(355)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(724), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1582), + [sym_conditional_expression] = STATE(1582), + [sym_logical_or_expression] = STATE(1582), + [sym_logical_and_expression] = STATE(1582), + [sym_equality_expression] = STATE(1582), + [sym_type_cast_expression] = STATE(1582), + [sym_type_test_expression] = STATE(1582), + [sym_relational_expression] = STATE(1582), + [sym_bitwise_or_expression] = STATE(1582), + [sym_bitwise_xor_expression] = STATE(1582), + [sym_bitwise_and_expression] = STATE(1582), + [sym_shift_expression] = STATE(1582), + [sym_additive_expression] = STATE(1582), + [sym_multiplicative_expression] = STATE(1582), + [sym__unary_expression] = STATE(1238), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1338), + [sym_comment] = STATE(355), + [sym_documentation_comment] = STATE(355), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(356)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(763), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(356), + [sym_documentation_comment] = STATE(356), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(357)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(767), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(357), + [sym_documentation_comment] = STATE(357), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(358)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(769), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(358), + [sym_documentation_comment] = STATE(358), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(359)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(770), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(359), + [sym_documentation_comment] = STATE(359), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(360)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(771), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(360), + [sym_documentation_comment] = STATE(360), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(361)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(563), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(361), + [sym_documentation_comment] = STATE(361), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(362)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(565), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(362), + [sym_documentation_comment] = STATE(362), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(363)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(566), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(363), + [sym_documentation_comment] = STATE(363), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(364)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(567), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(364), + [sym_documentation_comment] = STATE(364), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(365)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(568), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(365), + [sym_documentation_comment] = STATE(365), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(366)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(569), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(366), + [sym_documentation_comment] = STATE(366), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(367)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(570), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(367), + [sym_documentation_comment] = STATE(367), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(368)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(571), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(368), + [sym_documentation_comment] = STATE(368), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(369)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(573), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(369), + [sym_documentation_comment] = STATE(369), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(370)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym__real_expression] = STATE(575), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym_if_null_expression] = STATE(1100), + [sym_conditional_expression] = STATE(1100), + [sym_logical_or_expression] = STATE(1100), + [sym_logical_and_expression] = STATE(1100), + [sym_equality_expression] = STATE(1100), + [sym_type_cast_expression] = STATE(1100), + [sym_type_test_expression] = STATE(1100), + [sym_relational_expression] = STATE(1100), + [sym_bitwise_or_expression] = STATE(1100), + [sym_bitwise_xor_expression] = STATE(1100), + [sym_bitwise_and_expression] = STATE(1100), + [sym_shift_expression] = STATE(1100), + [sym_additive_expression] = STATE(1100), + [sym_multiplicative_expression] = STATE(1100), + [sym__unary_expression] = STATE(948), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(1368), + [sym_comment] = STATE(370), + [sym_documentation_comment] = STATE(370), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(371)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(773), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(371), + [sym_documentation_comment] = STATE(371), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(372)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym__real_expression] = STATE(753), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym_if_null_expression] = STATE(1724), + [sym_conditional_expression] = STATE(1724), + [sym_logical_or_expression] = STATE(1724), + [sym_logical_and_expression] = STATE(1724), + [sym_equality_expression] = STATE(1724), + [sym_type_cast_expression] = STATE(1724), + [sym_type_test_expression] = STATE(1724), + [sym_relational_expression] = STATE(1724), + [sym_bitwise_or_expression] = STATE(1724), + [sym_bitwise_xor_expression] = STATE(1724), + [sym_bitwise_and_expression] = STATE(1724), + [sym_shift_expression] = STATE(1724), + [sym_additive_expression] = STATE(1724), + [sym_multiplicative_expression] = STATE(1724), + [sym__unary_expression] = STATE(1352), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(1340), + [sym_comment] = STATE(372), + [sym_documentation_comment] = STATE(372), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(373)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym__real_expression] = STATE(683), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym_if_null_expression] = STATE(1464), + [sym_conditional_expression] = STATE(1464), + [sym_logical_or_expression] = STATE(1464), + [sym_logical_and_expression] = STATE(1464), + [sym_equality_expression] = STATE(1464), + [sym_type_cast_expression] = STATE(1464), + [sym_type_test_expression] = STATE(1464), + [sym_relational_expression] = STATE(1464), + [sym_bitwise_or_expression] = STATE(1464), + [sym_bitwise_xor_expression] = STATE(1464), + [sym_bitwise_and_expression] = STATE(1464), + [sym_shift_expression] = STATE(1464), + [sym_additive_expression] = STATE(1464), + [sym_multiplicative_expression] = STATE(1464), + [sym__unary_expression] = STATE(1091), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(1353), + [sym_comment] = STATE(373), + [sym_documentation_comment] = STATE(373), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(374)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3218), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(374), + [sym_documentation_comment] = STATE(374), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(860), + [anon_sym_POUND] = ACTIONS(863), + [sym_decimal_integer_literal] = ACTIONS(866), + [sym_hex_integer_literal] = ACTIONS(869), + [sym_decimal_floating_point_literal] = ACTIONS(866), + [anon_sym_true] = ACTIONS(872), + [anon_sym_false] = ACTIONS(875), + [anon_sym_DQUOTE] = ACTIONS(878), + [anon_sym_SQUOTE] = ACTIONS(881), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(884), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(887), + [anon_sym_r_DQUOTE] = ACTIONS(890), + [anon_sym_r_SQUOTE] = ACTIONS(893), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(896), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(899), + [anon_sym_LBRACE] = ACTIONS(902), + [anon_sym_LBRACK] = ACTIONS(905), + [anon_sym_null] = ACTIONS(908), + [anon_sym_LPAREN] = ACTIONS(911), + [anon_sym_throw] = ACTIONS(914), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(916), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_increment_operator] = ACTIONS(919), + [sym_minus_operator] = ACTIONS(921), + [anon_sym_BANG] = ACTIONS(914), + [anon_sym_TILDE] = ACTIONS(919), + [anon_sym_await] = ACTIONS(914), + [anon_sym_switch] = ACTIONS(914), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_rethrow_builtin] = ACTIONS(914), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(914), + [anon_sym_set] = ACTIONS(914), + [anon_sym_new] = ACTIONS(914), + [sym_const_builtin] = ACTIONS(924), + [anon_sym_this] = ACTIONS(914), + [anon_sym_super] = ACTIONS(914), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(375)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(2992), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym_switch_statement_case] = STATE(2654), + [sym_switch_statement_default] = STATE(3520), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym_case_builtin] = STATE(429), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_label] = STATE(2997), + [sym_comment] = STATE(375), + [sym_documentation_comment] = STATE(375), + [aux_sym_string_literal_repeat1] = STATE(1487), + [aux_sym_switch_block_repeat1] = STATE(2175), + [aux_sym_switch_statement_case_repeat1] = STATE(2556), + [sym_identifier] = ACTIONS(927), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(957), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_default] = ACTIONS(969), + [anon_sym_case] = ACTIONS(971), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(376)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3181), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(2949), + [sym_object_pattern] = STATE(2147), + [sym_annotation] = STATE(1415), + [sym__metadata] = STATE(2122), + [sym__type] = STATE(2718), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym_record_type_field] = STATE(2817), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(376), + [sym_documentation_comment] = STATE(376), + [aux_sym_string_literal_repeat1] = STATE(1487), + [aux_sym__metadata_repeat1] = STATE(1329), + [sym_identifier] = ACTIONS(975), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(977), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(492), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(377)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1318), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(377), + [sym_documentation_comment] = STATE(377), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_for] = ACTIONS(979), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(378)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1318), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(378), + [sym_documentation_comment] = STATE(378), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_for] = ACTIONS(981), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(379)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1318), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(379), + [sym_documentation_comment] = STATE(379), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_for] = ACTIONS(983), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(380)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1318), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(380), + [sym_documentation_comment] = STATE(380), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_for] = ACTIONS(985), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(381)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1405), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(381), + [sym_documentation_comment] = STATE(381), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(382)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(914), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(382), + [sym_documentation_comment] = STATE(382), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(383)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3012), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(383), + [sym_documentation_comment] = STATE(383), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_RBRACK] = ACTIONS(989), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(384)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1318), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(384), + [sym_documentation_comment] = STATE(384), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(385)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3194), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(385), + [sym_documentation_comment] = STATE(385), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_RBRACK] = ACTIONS(993), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(386)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1314), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(386), + [sym_documentation_comment] = STATE(386), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(387)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3194), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(387), + [sym_documentation_comment] = STATE(387), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_RBRACK] = ACTIONS(995), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(388)] = { + [sym_comment] = STATE(388), + [sym_documentation_comment] = STATE(388), + [sym_identifier] = ACTIONS(997), + [anon_sym_POUND] = ACTIONS(999), + [sym_decimal_integer_literal] = ACTIONS(997), + [sym_hex_integer_literal] = ACTIONS(999), + [sym_decimal_floating_point_literal] = ACTIONS(997), + [anon_sym_true] = ACTIONS(997), + [anon_sym_false] = ACTIONS(997), + [anon_sym_DQUOTE] = ACTIONS(997), + [anon_sym_SQUOTE] = ACTIONS(997), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_r_DQUOTE] = ACTIONS(997), + [anon_sym_r_SQUOTE] = ACTIONS(997), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_LBRACE] = ACTIONS(999), + [anon_sym_RBRACE] = ACTIONS(999), + [anon_sym_LBRACK] = ACTIONS(1001), + [anon_sym_null] = ACTIONS(997), + [anon_sym_LPAREN] = ACTIONS(1001), + [anon_sym_throw] = ACTIONS(997), + [anon_sym_EQ] = ACTIONS(1004), + [anon_sym_QMARK_QMARK] = ACTIONS(1006), + [anon_sym_QMARK] = ACTIONS(1008), + [sym_equality_operator] = ACTIONS(1006), + [anon_sym_LT] = ACTIONS(1010), + [anon_sym_GT] = ACTIONS(1008), + [anon_sym_LT_EQ] = ACTIONS(1006), + [anon_sym_GT_EQ] = ACTIONS(1006), + [anon_sym_PIPE] = ACTIONS(1008), + [anon_sym_CARET] = ACTIONS(1006), + [anon_sym_AMP] = ACTIONS(1008), + [anon_sym_LT_LT] = ACTIONS(1006), + [anon_sym_GT_GT] = ACTIONS(1008), + [anon_sym_GT_GT_GT] = ACTIONS(1006), + [sym__additive_operator] = ACTIONS(1008), + [anon_sym_STAR] = ACTIONS(1006), + [anon_sym_SLASH] = ACTIONS(1008), + [anon_sym_PERCENT] = ACTIONS(1006), + [anon_sym_TILDE_SLASH] = ACTIONS(1006), + [sym_increment_operator] = ACTIONS(999), + [sym_minus_operator] = ACTIONS(997), + [anon_sym_BANG] = ACTIONS(1010), + [anon_sym_TILDE] = ACTIONS(997), + [anon_sym_await] = ACTIONS(997), + [anon_sym_is] = ACTIONS(1008), + [anon_sym_as] = ACTIONS(1008), + [anon_sym_DOT] = ACTIONS(1008), + [anon_sym_DOT_DOT] = ACTIONS(1006), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1006), + [anon_sym_QMARK_DOT] = ACTIONS(1008), + [anon_sym_SEMI] = ACTIONS(1006), + [anon_sym_switch] = ACTIONS(997), + [anon_sym_default] = ACTIONS(997), + [anon_sym_do] = ACTIONS(997), + [anon_sym_while] = ACTIONS(997), + [anon_sym_continue] = ACTIONS(997), + [anon_sym_yield] = ACTIONS(997), + [anon_sym_return] = ACTIONS(997), + [anon_sym_try] = ACTIONS(997), + [anon_sym_if] = ACTIONS(997), + [anon_sym_case] = ACTIONS(997), + [anon_sym_else] = ACTIONS(997), + [anon_sym_for] = ACTIONS(997), + [anon_sym_AT] = ACTIONS(999), + [anon_sym_final] = ACTIONS(997), + [sym_void_type] = ACTIONS(997), + [anon_sym_var] = ACTIONS(997), + [sym_break_builtin] = ACTIONS(997), + [sym_assert_builtin] = ACTIONS(997), + [sym_rethrow_builtin] = ACTIONS(997), + [anon_sym_covariant] = ACTIONS(997), + [anon_sym_Function] = ACTIONS(997), + [anon_sym_get] = ACTIONS(997), + [anon_sym_set] = ACTIONS(997), + [anon_sym_new] = ACTIONS(997), + [anon_sym_AMP_AMP] = ACTIONS(1006), + [anon_sym_PIPE_PIPE] = ACTIONS(1006), + [sym_const_builtin] = ACTIONS(997), + [anon_sym_late] = ACTIONS(997), + [anon_sym_this] = ACTIONS(997), + [anon_sym_super] = ACTIONS(997), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(389)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1401), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(389), + [sym_documentation_comment] = STATE(389), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(390)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1106), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(390), + [sym_documentation_comment] = STATE(390), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(391)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1107), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(391), + [sym_documentation_comment] = STATE(391), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(392)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3194), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(392), + [sym_documentation_comment] = STATE(392), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_RBRACK] = ACTIONS(1013), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(393)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(964), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(393), + [sym_documentation_comment] = STATE(393), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(394)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3030), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(394), + [sym_documentation_comment] = STATE(394), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_RBRACK] = ACTIONS(1015), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(395)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3238), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(1327), + [sym_unary_expression] = STATE(1320), + [sym__postfix_expression] = STATE(1320), + [sym_postfix_expression] = STATE(1322), + [sym_prefix_operator] = STATE(395), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1336), + [sym_await_expression] = STATE(1321), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(663), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(395), + [sym_documentation_comment] = STATE(395), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(113), + [sym_minus_operator] = ACTIONS(117), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(426), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(396)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym__unary_expression] = STATE(1489), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(2673), + [sym_comment] = STATE(396), + [sym_documentation_comment] = STATE(396), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(397)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym__unary_expression] = STATE(1490), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(2673), + [sym_comment] = STATE(397), + [sym_documentation_comment] = STATE(397), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(398)] = { + [sym_comment] = STATE(398), + [sym_documentation_comment] = STATE(398), + [sym_identifier] = ACTIONS(997), + [anon_sym_POUND] = ACTIONS(999), + [sym_decimal_integer_literal] = ACTIONS(997), + [sym_hex_integer_literal] = ACTIONS(999), + [sym_decimal_floating_point_literal] = ACTIONS(997), + [anon_sym_true] = ACTIONS(997), + [anon_sym_false] = ACTIONS(997), + [anon_sym_DQUOTE] = ACTIONS(997), + [anon_sym_SQUOTE] = ACTIONS(997), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_r_DQUOTE] = ACTIONS(997), + [anon_sym_r_SQUOTE] = ACTIONS(997), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_LBRACE] = ACTIONS(999), + [anon_sym_RBRACE] = ACTIONS(1001), + [anon_sym_LBRACK] = ACTIONS(1001), + [anon_sym_COMMA] = ACTIONS(1006), + [anon_sym_COLON] = ACTIONS(1006), + [anon_sym_null] = ACTIONS(997), + [anon_sym_LPAREN] = ACTIONS(1001), + [anon_sym_throw] = ACTIONS(997), + [anon_sym_EQ] = ACTIONS(1004), + [anon_sym_QMARK_QMARK] = ACTIONS(1006), + [anon_sym_QMARK] = ACTIONS(1008), + [sym_equality_operator] = ACTIONS(1006), + [anon_sym_LT] = ACTIONS(1010), + [anon_sym_GT] = ACTIONS(1008), + [anon_sym_LT_EQ] = ACTIONS(1006), + [anon_sym_GT_EQ] = ACTIONS(1006), + [anon_sym_PIPE] = ACTIONS(1008), + [anon_sym_CARET] = ACTIONS(1006), + [anon_sym_AMP] = ACTIONS(1008), + [anon_sym_LT_LT] = ACTIONS(1006), + [anon_sym_GT_GT] = ACTIONS(1008), + [anon_sym_GT_GT_GT] = ACTIONS(1006), + [sym__additive_operator] = ACTIONS(1008), + [anon_sym_STAR] = ACTIONS(1006), + [anon_sym_SLASH] = ACTIONS(1008), + [anon_sym_PERCENT] = ACTIONS(1006), + [anon_sym_TILDE_SLASH] = ACTIONS(1006), + [sym_increment_operator] = ACTIONS(999), + [sym_minus_operator] = ACTIONS(997), + [anon_sym_BANG] = ACTIONS(1010), + [anon_sym_TILDE] = ACTIONS(997), + [anon_sym_await] = ACTIONS(997), + [anon_sym_is] = ACTIONS(1008), + [anon_sym_as] = ACTIONS(1008), + [anon_sym_DOT] = ACTIONS(1008), + [anon_sym_DOT_DOT] = ACTIONS(1006), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1006), + [anon_sym_QMARK_DOT] = ACTIONS(1008), + [anon_sym_SEMI] = ACTIONS(1006), + [anon_sym_switch] = ACTIONS(997), + [anon_sym_do] = ACTIONS(997), + [anon_sym_while] = ACTIONS(997), + [anon_sym_continue] = ACTIONS(997), + [anon_sym_yield] = ACTIONS(997), + [anon_sym_return] = ACTIONS(997), + [anon_sym_try] = ACTIONS(997), + [anon_sym_if] = ACTIONS(997), + [anon_sym_else] = ACTIONS(1010), + [anon_sym_for] = ACTIONS(997), + [anon_sym_AT] = ACTIONS(999), + [anon_sym_final] = ACTIONS(997), + [sym_void_type] = ACTIONS(997), + [anon_sym_var] = ACTIONS(997), + [sym_break_builtin] = ACTIONS(997), + [sym_assert_builtin] = ACTIONS(997), + [sym_rethrow_builtin] = ACTIONS(997), + [anon_sym_covariant] = ACTIONS(997), + [anon_sym_Function] = ACTIONS(997), + [anon_sym_get] = ACTIONS(997), + [anon_sym_set] = ACTIONS(997), + [anon_sym_new] = ACTIONS(997), + [anon_sym_AMP_AMP] = ACTIONS(1006), + [anon_sym_PIPE_PIPE] = ACTIONS(1006), + [sym_const_builtin] = ACTIONS(997), + [anon_sym_late] = ACTIONS(997), + [anon_sym_this] = ACTIONS(997), + [anon_sym_super] = ACTIONS(997), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(399)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3199), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1126), + [sym_unary_expression] = STATE(1101), + [sym__postfix_expression] = STATE(1101), + [sym_postfix_expression] = STATE(1102), + [sym_prefix_operator] = STATE(390), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1337), + [sym_await_expression] = STATE(1103), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(690), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(399), + [sym_documentation_comment] = STATE(399), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(736), + [sym_minus_operator] = ACTIONS(738), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(740), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(400)] = { + [sym__bool_literal] = STATE(1133), + [sym__numeric_literal] = STATE(1133), + [sym__literal] = STATE(1134), + [sym_symbol_literal] = STATE(1133), + [sym_true] = STATE(1099), + [sym_false] = STATE(1099), + [sym_string_literal] = STATE(1133), + [sym__string_literal_double_quotes] = STATE(747), + [sym__string_literal_single_quotes] = STATE(747), + [sym__string_literal_double_quotes_multiple] = STATE(747), + [sym__string_literal_single_quotes_multiple] = STATE(747), + [sym__raw_string_literal_double_quotes] = STATE(747), + [sym__raw_string_literal_single_quotes] = STATE(747), + [sym__raw_string_literal_double_quotes_multiple] = STATE(747), + [sym__raw_string_literal_single_quotes_multiple] = STATE(747), + [sym_list_literal] = STATE(1133), + [sym_set_or_map_literal] = STATE(1133), + [sym_null_literal] = STATE(1133), + [sym_record_literal] = STATE(1133), + [sym__record_literal_no_const] = STATE(1135), + [sym_assignable_expression] = STATE(3151), + [sym_function_expression] = STATE(1134), + [sym__unary_expression] = STATE(1403), + [sym_unary_expression] = STATE(1394), + [sym__postfix_expression] = STATE(1394), + [sym_postfix_expression] = STATE(1375), + [sym_prefix_operator] = STATE(400), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1324), + [sym_await_expression] = STATE(1398), + [sym_new_expression] = STATE(1134), + [sym_const_object_expression] = STATE(1134), + [sym__primary] = STATE(698), + [sym_parenthesized_expression] = STATE(1134), + [sym_constructor_invocation] = STATE(694), + [sym_constructor_tearoff] = STATE(1134), + [sym_type_arguments] = STATE(3283), + [sym_switch_expression] = STATE(1134), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2906), + [sym__formal_parameter_part] = STATE(2436), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1139), + [sym__set] = STATE(1139), + [sym__new_builtin] = STATE(2111), + [sym_this] = STATE(1134), + [sym_super] = STATE(2647), + [sym_comment] = STATE(400), + [sym_documentation_comment] = STATE(400), + [aux_sym_string_literal_repeat1] = STATE(590), + [sym_identifier] = ACTIONS(858), + [anon_sym_POUND] = ACTIONS(700), + [sym_decimal_integer_literal] = ACTIONS(702), + [sym_hex_integer_literal] = ACTIONS(704), + [sym_decimal_floating_point_literal] = ACTIONS(702), + [anon_sym_true] = ACTIONS(706), + [anon_sym_false] = ACTIONS(708), + [anon_sym_DQUOTE] = ACTIONS(710), + [anon_sym_SQUOTE] = ACTIONS(712), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(714), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(716), + [anon_sym_r_DQUOTE] = ACTIONS(718), + [anon_sym_r_SQUOTE] = ACTIONS(720), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(722), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(724), + [anon_sym_LBRACE] = ACTIONS(764), + [anon_sym_LBRACK] = ACTIONS(766), + [anon_sym_null] = ACTIONS(730), + [anon_sym_LPAREN] = ACTIONS(768), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(838), + [sym_minus_operator] = ACTIONS(840), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(842), + [anon_sym_switch] = ACTIONS(742), + [anon_sym_get] = ACTIONS(746), + [anon_sym_set] = ACTIONS(748), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(750), + [anon_sym_this] = ACTIONS(752), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(401)] = { + [sym__bool_literal] = STATE(920), + [sym__numeric_literal] = STATE(920), + [sym__literal] = STATE(930), + [sym_symbol_literal] = STATE(920), + [sym_true] = STATE(933), + [sym_false] = STATE(933), + [sym_string_literal] = STATE(920), + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_list_literal] = STATE(920), + [sym_set_or_map_literal] = STATE(920), + [sym_null_literal] = STATE(920), + [sym_record_literal] = STATE(920), + [sym__record_literal_no_const] = STATE(900), + [sym_assignable_expression] = STATE(3090), + [sym_function_expression] = STATE(930), + [sym__unary_expression] = STATE(913), + [sym_unary_expression] = STATE(907), + [sym__postfix_expression] = STATE(907), + [sym_postfix_expression] = STATE(909), + [sym_prefix_operator] = STATE(401), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1333), + [sym_await_expression] = STATE(910), + [sym_new_expression] = STATE(930), + [sym_const_object_expression] = STATE(930), + [sym__primary] = STATE(638), + [sym_parenthesized_expression] = STATE(930), + [sym_constructor_invocation] = STATE(654), + [sym_constructor_tearoff] = STATE(930), + [sym_type_arguments] = STATE(3243), + [sym_switch_expression] = STATE(930), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2784), + [sym__formal_parameter_part] = STATE(2417), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(926), + [sym__set] = STATE(926), + [sym__new_builtin] = STATE(2081), + [sym_this] = STATE(930), + [sym_super] = STATE(2641), + [sym_comment] = STATE(401), + [sym_documentation_comment] = STATE(401), + [aux_sym_string_literal_repeat1] = STATE(478), + [sym_identifier] = ACTIONS(854), + [anon_sym_POUND] = ACTIONS(73), + [sym_decimal_integer_literal] = ACTIONS(75), + [sym_hex_integer_literal] = ACTIONS(77), + [sym_decimal_floating_point_literal] = ACTIONS(75), + [anon_sym_true] = ACTIONS(79), + [anon_sym_false] = ACTIONS(81), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_LBRACE] = ACTIONS(828), + [anon_sym_LBRACK] = ACTIONS(830), + [anon_sym_null] = ACTIONS(105), + [anon_sym_LPAREN] = ACTIONS(832), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(692), + [sym_minus_operator] = ACTIONS(694), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(696), + [anon_sym_switch] = ACTIONS(380), + [anon_sym_get] = ACTIONS(155), + [anon_sym_set] = ACTIONS(157), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(482), + [anon_sym_this] = ACTIONS(163), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(402)] = { + [sym__bool_literal] = STATE(1229), + [sym__numeric_literal] = STATE(1229), + [sym__literal] = STATE(1231), + [sym_symbol_literal] = STATE(1229), + [sym_true] = STATE(1235), + [sym_false] = STATE(1235), + [sym_string_literal] = STATE(1229), + [sym__string_literal_double_quotes] = STATE(808), + [sym__string_literal_single_quotes] = STATE(808), + [sym__string_literal_double_quotes_multiple] = STATE(808), + [sym__string_literal_single_quotes_multiple] = STATE(808), + [sym__raw_string_literal_double_quotes] = STATE(808), + [sym__raw_string_literal_single_quotes] = STATE(808), + [sym__raw_string_literal_double_quotes_multiple] = STATE(808), + [sym__raw_string_literal_single_quotes_multiple] = STATE(808), + [sym_list_literal] = STATE(1229), + [sym_set_or_map_literal] = STATE(1229), + [sym_null_literal] = STATE(1229), + [sym_record_literal] = STATE(1229), + [sym__record_literal_no_const] = STATE(1236), + [sym_assignable_expression] = STATE(3168), + [sym_function_expression] = STATE(1231), + [sym__unary_expression] = STATE(1509), + [sym_unary_expression] = STATE(1497), + [sym__postfix_expression] = STATE(1497), + [sym_postfix_expression] = STATE(1469), + [sym_prefix_operator] = STATE(396), + [sym_negation_operator] = STATE(1345), + [sym__exclamation_operator] = STATE(1347), + [sym_tilde_operator] = STATE(1334), + [sym_await_expression] = STATE(1476), + [sym_new_expression] = STATE(1231), + [sym_const_object_expression] = STATE(1231), + [sym__primary] = STATE(726), + [sym_parenthesized_expression] = STATE(1231), + [sym_constructor_invocation] = STATE(727), + [sym_constructor_tearoff] = STATE(1231), + [sym_type_arguments] = STATE(3269), + [sym_switch_expression] = STATE(1231), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2859), + [sym__formal_parameter_part] = STATE(2421), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(1254), + [sym__set] = STATE(1254), + [sym__new_builtin] = STATE(2107), + [sym_this] = STATE(1231), + [sym_super] = STATE(2673), + [sym_comment] = STATE(402), + [sym_documentation_comment] = STATE(402), + [aux_sym_string_literal_repeat1] = STATE(630), + [sym_identifier] = ACTIONS(856), + [anon_sym_POUND] = ACTIONS(774), + [sym_decimal_integer_literal] = ACTIONS(776), + [sym_hex_integer_literal] = ACTIONS(778), + [sym_decimal_floating_point_literal] = ACTIONS(776), + [anon_sym_true] = ACTIONS(780), + [anon_sym_false] = ACTIONS(782), + [anon_sym_DQUOTE] = ACTIONS(784), + [anon_sym_SQUOTE] = ACTIONS(786), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(788), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(790), + [anon_sym_r_DQUOTE] = ACTIONS(792), + [anon_sym_r_SQUOTE] = ACTIONS(794), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(796), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(798), + [anon_sym_LBRACE] = ACTIONS(800), + [anon_sym_LBRACK] = ACTIONS(802), + [anon_sym_null] = ACTIONS(804), + [anon_sym_LPAREN] = ACTIONS(806), + [anon_sym_LT] = ACTIONS(111), + [sym_increment_operator] = ACTIONS(810), + [sym_minus_operator] = ACTIONS(812), + [anon_sym_BANG] = ACTIONS(119), + [anon_sym_TILDE] = ACTIONS(121), + [anon_sym_await] = ACTIONS(814), + [anon_sym_switch] = ACTIONS(816), + [anon_sym_get] = ACTIONS(818), + [anon_sym_set] = ACTIONS(820), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(822), + [anon_sym_this] = ACTIONS(824), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(403)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(403), + [sym_documentation_comment] = STATE(403), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1017), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(404)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(404), + [sym_documentation_comment] = STATE(404), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(1021), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(405)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(405), + [sym_documentation_comment] = STATE(405), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1023), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(406)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(406), + [sym_documentation_comment] = STATE(406), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(1025), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(407)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(407), + [sym_documentation_comment] = STATE(407), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(1027), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(408)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(408), + [sym_documentation_comment] = STATE(408), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1029), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(409)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(409), + [sym_documentation_comment] = STATE(409), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(1031), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(410)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(410), + [sym_documentation_comment] = STATE(410), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [anon_sym_RPAREN] = ACTIONS(1033), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(411)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(411), + [sym_documentation_comment] = STATE(411), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1035), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(412)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(412), + [sym_documentation_comment] = STATE(412), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1037), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(413)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(413), + [sym_documentation_comment] = STATE(413), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1039), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(414)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(414), + [sym_documentation_comment] = STATE(414), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1041), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(415)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3248), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym__list_pattern_element] = STATE(3194), + [sym_rest_pattern] = STATE(3248), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(415), + [sym_documentation_comment] = STATE(415), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_DOT_DOT_DOT] = ACTIONS(991), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(416)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(416), + [sym_documentation_comment] = STATE(416), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_RBRACE] = ACTIONS(1043), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(417)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(2716), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(417), + [sym_documentation_comment] = STATE(417), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(418)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(2876), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(418), + [sym_documentation_comment] = STATE(418), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(419)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(2992), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(419), + [sym_documentation_comment] = STATE(419), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(420)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(3234), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(420), + [sym_documentation_comment] = STATE(420), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(421)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(3081), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(421), + [sym_documentation_comment] = STATE(421), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(422)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3320), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym__pattern_field] = STATE(2896), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(422), + [sym_documentation_comment] = STATE(422), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(1019), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COLON] = ACTIONS(422), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(423)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(2808), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(423), + [sym_documentation_comment] = STATE(423), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(424)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3302), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(424), + [sym_documentation_comment] = STATE(424), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_COMMA] = ACTIONS(472), + [anon_sym_RBRACK] = ACTIONS(472), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(425)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym_switch_expression_case] = STATE(2923), + [sym__guarded_pattern] = STATE(3511), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(425), + [sym_documentation_comment] = STATE(425), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(426)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3508), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(426), + [sym_documentation_comment] = STATE(426), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(427)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3386), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(427), + [sym_documentation_comment] = STATE(427), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(428)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3594), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(428), + [sym_documentation_comment] = STATE(428), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(429)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3375), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(429), + [sym_documentation_comment] = STATE(429), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(430)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3378), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(430), + [sym_documentation_comment] = STATE(430), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(431)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__guarded_pattern] = STATE(3514), + [sym__pattern] = STATE(2651), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(431), + [sym_documentation_comment] = STATE(431), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(432)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3192), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(432), + [sym_documentation_comment] = STATE(432), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(433)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3218), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(433), + [sym_documentation_comment] = STATE(433), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(434)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__pattern] = STATE(3169), + [sym__logical_or_pattern] = STATE(2455), + [sym__logical_and_pattern] = STATE(2203), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(434), + [sym_documentation_comment] = STATE(434), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(435)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(533), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym_library_name] = STATE(439), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(435), + [sym_documentation_comment] = STATE(435), + [aux_sym_program_repeat1] = STATE(441), + [aux_sym_program_repeat2] = STATE(458), + [aux_sym_program_repeat3] = STATE(461), + [aux_sym_program_repeat4] = STATE(481), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_library] = ACTIONS(39), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(436)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__logical_and_pattern] = STATE(2347), + [sym__relational_pattern] = STATE(2162), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(436), + [sym_documentation_comment] = STATE(436), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(437)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(561), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(437), + [sym_documentation_comment] = STATE(437), + [aux_sym_program_repeat1] = STATE(441), + [aux_sym_program_repeat2] = STATE(458), + [aux_sym_program_repeat3] = STATE(461), + [aux_sym_program_repeat4] = STATE(481), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(438)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(561), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(438), + [sym_documentation_comment] = STATE(438), + [aux_sym_program_repeat1] = STATE(1035), + [aux_sym_program_repeat2] = STATE(458), + [aux_sym_program_repeat3] = STATE(461), + [aux_sym_program_repeat4] = STATE(481), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(439)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(561), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(439), + [sym_documentation_comment] = STATE(439), + [aux_sym_program_repeat1] = STATE(442), + [aux_sym_program_repeat2] = STATE(457), + [aux_sym_program_repeat3] = STATE(465), + [aux_sym_program_repeat4] = STATE(476), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1047), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(440)] = { + [sym__bool_literal] = STATE(2155), + [sym__numeric_literal] = STATE(2155), + [sym_symbol_literal] = STATE(2155), + [sym_true] = STATE(2145), + [sym_false] = STATE(2145), + [sym_string_literal] = STATE(2155), + [sym__string_literal_double_quotes] = STATE(1854), + [sym__string_literal_single_quotes] = STATE(1854), + [sym__string_literal_double_quotes_multiple] = STATE(1854), + [sym__string_literal_single_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_double_quotes] = STATE(1854), + [sym__raw_string_literal_single_quotes] = STATE(1854), + [sym__raw_string_literal_double_quotes_multiple] = STATE(1854), + [sym__raw_string_literal_single_quotes_multiple] = STATE(1854), + [sym_null_literal] = STATE(2155), + [sym_relational_operator] = STATE(328), + [sym_const_object_expression] = STATE(2155), + [sym_type_arguments] = STATE(3063), + [sym__relational_pattern] = STATE(2227), + [sym__unary_pattern] = STATE(2285), + [sym__primary_pattern] = STATE(2144), + [sym_cast_pattern] = STATE(2286), + [sym_null_check_pattern] = STATE(2286), + [sym_null_assert_pattern] = STATE(2286), + [sym_constant_pattern] = STATE(2147), + [sym_variable_pattern] = STATE(2147), + [sym__parenthesized_pattern] = STATE(2147), + [sym_list_pattern] = STATE(2147), + [sym_map_pattern] = STATE(2147), + [sym_record_pattern] = STATE(2147), + [sym_object_pattern] = STATE(2147), + [sym__type] = STATE(3596), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(2176), + [sym__final_var_or_type] = STATE(3598), + [sym_inferred_type] = STATE(3596), + [sym_qualified] = STATE(2155), + [sym__function_builtin_identifier] = STATE(1502), + [sym_final_builtin] = STATE(2118), + [sym_comment] = STATE(440), + [sym_documentation_comment] = STATE(440), + [aux_sym_string_literal_repeat1] = STATE(1487), + [sym_identifier] = ACTIONS(987), + [anon_sym_POUND] = ACTIONS(929), + [sym_decimal_integer_literal] = ACTIONS(931), + [sym_hex_integer_literal] = ACTIONS(933), + [sym_decimal_floating_point_literal] = ACTIONS(931), + [anon_sym_true] = ACTIONS(935), + [anon_sym_false] = ACTIONS(937), + [anon_sym_DQUOTE] = ACTIONS(939), + [anon_sym_SQUOTE] = ACTIONS(941), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(943), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(945), + [anon_sym_r_DQUOTE] = ACTIONS(947), + [anon_sym_r_SQUOTE] = ACTIONS(949), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(951), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(953), + [anon_sym_LBRACE] = ACTIONS(955), + [anon_sym_LBRACK] = ACTIONS(959), + [anon_sym_null] = ACTIONS(961), + [anon_sym_LPAREN] = ACTIONS(963), + [sym_equality_operator] = ACTIONS(364), + [anon_sym_LT] = ACTIONS(965), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [sym_minus_operator] = ACTIONS(967), + [anon_sym_final] = ACTIONS(145), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [sym_const_builtin] = ACTIONS(973), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(441)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(561), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(441), + [sym_documentation_comment] = STATE(441), + [aux_sym_program_repeat1] = STATE(1035), + [aux_sym_program_repeat2] = STATE(457), + [aux_sym_program_repeat3] = STATE(465), + [aux_sym_program_repeat4] = STATE(476), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1047), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(442)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_import_or_export] = STATE(1570), + [sym_library_import] = STATE(1580), + [sym_library_export] = STATE(1580), + [sym_import_specification] = STATE(1595), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(561), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__export] = STATE(1864), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym__import] = STATE(1866), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(442), + [sym_documentation_comment] = STATE(442), + [aux_sym_program_repeat1] = STATE(1035), + [aux_sym_program_repeat2] = STATE(455), + [aux_sym_program_repeat3] = STATE(464), + [aux_sym_program_repeat4] = STATE(477), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1049), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_export] = ACTIONS(43), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_import] = ACTIONS(49), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(443)] = { + [sym_comment] = STATE(443), + [sym_documentation_comment] = STATE(443), + [ts_builtin_sym_end] = ACTIONS(999), + [sym_identifier] = ACTIONS(997), + [anon_sym_POUND] = ACTIONS(999), + [sym_decimal_integer_literal] = ACTIONS(997), + [sym_hex_integer_literal] = ACTIONS(999), + [sym_decimal_floating_point_literal] = ACTIONS(997), + [anon_sym_true] = ACTIONS(997), + [anon_sym_false] = ACTIONS(997), + [anon_sym_DQUOTE] = ACTIONS(997), + [anon_sym_SQUOTE] = ACTIONS(997), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_r_DQUOTE] = ACTIONS(997), + [anon_sym_r_SQUOTE] = ACTIONS(997), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_LBRACE] = ACTIONS(999), + [anon_sym_RBRACE] = ACTIONS(999), + [anon_sym_LBRACK] = ACTIONS(999), + [anon_sym_null] = ACTIONS(997), + [anon_sym_LPAREN] = ACTIONS(999), + [anon_sym_throw] = ACTIONS(997), + [anon_sym_QMARK] = ACTIONS(997), + [anon_sym_LT] = ACTIONS(999), + [sym_increment_operator] = ACTIONS(999), + [sym_minus_operator] = ACTIONS(997), + [anon_sym_BANG] = ACTIONS(999), + [anon_sym_TILDE] = ACTIONS(999), + [anon_sym_await] = ACTIONS(997), + [anon_sym_DOT] = ACTIONS(997), + [anon_sym_QMARK_DOT] = ACTIONS(999), + [anon_sym_switch] = ACTIONS(997), + [anon_sym_default] = ACTIONS(997), + [anon_sym_do] = ACTIONS(997), + [anon_sym_while] = ACTIONS(997), + [anon_sym_continue] = ACTIONS(997), + [anon_sym_yield] = ACTIONS(997), + [anon_sym_return] = ACTIONS(997), + [anon_sym_try] = ACTIONS(997), + [anon_sym_if] = ACTIONS(997), + [anon_sym_case] = ACTIONS(997), + [anon_sym_else] = ACTIONS(997), + [anon_sym_for] = ACTIONS(997), + [anon_sym_AT] = ACTIONS(999), + [anon_sym_enum] = ACTIONS(997), + [anon_sym_final] = ACTIONS(997), + [anon_sym_inline] = ACTIONS(997), + [anon_sym_class] = ACTIONS(997), + [anon_sym_extension] = ACTIONS(997), + [sym_void_type] = ACTIONS(997), + [anon_sym_var] = ACTIONS(997), + [sym_break_builtin] = ACTIONS(997), + [sym_assert_builtin] = ACTIONS(997), + [sym_rethrow_builtin] = ACTIONS(997), + [anon_sym_covariant] = ACTIONS(997), + [anon_sym_factory] = ACTIONS(997), + [anon_sym_Function] = ACTIONS(997), + [anon_sym_get] = ACTIONS(997), + [anon_sym_interface] = ACTIONS(997), + [anon_sym_base] = ACTIONS(997), + [anon_sym_abstract] = ACTIONS(997), + [anon_sym_sealed] = ACTIONS(997), + [anon_sym_operator] = ACTIONS(997), + [anon_sym_mixin] = ACTIONS(997), + [anon_sym_set] = ACTIONS(997), + [anon_sym_static] = ACTIONS(997), + [anon_sym_typedef] = ACTIONS(997), + [anon_sym_new] = ACTIONS(997), + [sym_const_builtin] = ACTIONS(997), + [anon_sym_late] = ACTIONS(997), + [anon_sym_external] = ACTIONS(997), + [anon_sym_this] = ACTIONS(997), + [anon_sym_super] = ACTIONS(997), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(444)] = { + [sym_comment] = STATE(444), + [sym_documentation_comment] = STATE(444), + [ts_builtin_sym_end] = ACTIONS(1051), + [sym_identifier] = ACTIONS(1053), + [anon_sym_POUND] = ACTIONS(1051), + [sym_decimal_integer_literal] = ACTIONS(1053), + [sym_hex_integer_literal] = ACTIONS(1051), + [sym_decimal_floating_point_literal] = ACTIONS(1053), + [anon_sym_true] = ACTIONS(1053), + [anon_sym_false] = ACTIONS(1053), + [anon_sym_DQUOTE] = ACTIONS(1053), + [anon_sym_SQUOTE] = ACTIONS(1053), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1051), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1051), + [anon_sym_r_DQUOTE] = ACTIONS(1053), + [anon_sym_r_SQUOTE] = ACTIONS(1053), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1051), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1051), + [anon_sym_LBRACE] = ACTIONS(1051), + [anon_sym_RBRACE] = ACTIONS(1051), + [anon_sym_LBRACK] = ACTIONS(1051), + [anon_sym_null] = ACTIONS(1053), + [anon_sym_LPAREN] = ACTIONS(1051), + [anon_sym_throw] = ACTIONS(1053), + [anon_sym_QMARK] = ACTIONS(1053), + [anon_sym_LT] = ACTIONS(1051), + [sym_increment_operator] = ACTIONS(1051), + [sym_minus_operator] = ACTIONS(1053), + [anon_sym_BANG] = ACTIONS(1051), + [anon_sym_TILDE] = ACTIONS(1051), + [anon_sym_await] = ACTIONS(1053), + [anon_sym_DOT] = ACTIONS(1053), + [anon_sym_QMARK_DOT] = ACTIONS(1051), + [anon_sym_switch] = ACTIONS(1053), + [anon_sym_default] = ACTIONS(1053), + [anon_sym_do] = ACTIONS(1053), + [anon_sym_while] = ACTIONS(1053), + [anon_sym_continue] = ACTIONS(1053), + [anon_sym_yield] = ACTIONS(1053), + [anon_sym_return] = ACTIONS(1053), + [anon_sym_try] = ACTIONS(1053), + [anon_sym_if] = ACTIONS(1053), + [anon_sym_case] = ACTIONS(1053), + [anon_sym_else] = ACTIONS(1053), + [anon_sym_for] = ACTIONS(1053), + [anon_sym_AT] = ACTIONS(1051), + [anon_sym_enum] = ACTIONS(1053), + [anon_sym_final] = ACTIONS(1053), + [anon_sym_inline] = ACTIONS(1053), + [anon_sym_class] = ACTIONS(1053), + [anon_sym_extension] = ACTIONS(1053), + [sym_void_type] = ACTIONS(1053), + [anon_sym_var] = ACTIONS(1053), + [sym_break_builtin] = ACTIONS(1053), + [sym_assert_builtin] = ACTIONS(1053), + [sym_rethrow_builtin] = ACTIONS(1053), + [anon_sym_covariant] = ACTIONS(1053), + [anon_sym_factory] = ACTIONS(1053), + [anon_sym_Function] = ACTIONS(1053), + [anon_sym_get] = ACTIONS(1053), + [anon_sym_interface] = ACTIONS(1053), + [anon_sym_base] = ACTIONS(1053), + [anon_sym_abstract] = ACTIONS(1053), + [anon_sym_sealed] = ACTIONS(1053), + [anon_sym_operator] = ACTIONS(1053), + [anon_sym_mixin] = ACTIONS(1053), + [anon_sym_set] = ACTIONS(1053), + [anon_sym_static] = ACTIONS(1053), + [anon_sym_typedef] = ACTIONS(1053), + [anon_sym_new] = ACTIONS(1053), + [sym_const_builtin] = ACTIONS(1053), + [anon_sym_late] = ACTIONS(1053), + [anon_sym_external] = ACTIONS(1053), + [anon_sym_this] = ACTIONS(1053), + [anon_sym_super] = ACTIONS(1053), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(445)] = { + [sym_comment] = STATE(445), + [sym_documentation_comment] = STATE(445), + [ts_builtin_sym_end] = ACTIONS(1055), + [sym_identifier] = ACTIONS(1057), + [anon_sym_POUND] = ACTIONS(1055), + [sym_decimal_integer_literal] = ACTIONS(1057), + [sym_hex_integer_literal] = ACTIONS(1055), + [sym_decimal_floating_point_literal] = ACTIONS(1057), + [anon_sym_true] = ACTIONS(1057), + [anon_sym_false] = ACTIONS(1057), + [anon_sym_DQUOTE] = ACTIONS(1057), + [anon_sym_SQUOTE] = ACTIONS(1057), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1055), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1055), + [anon_sym_r_DQUOTE] = ACTIONS(1057), + [anon_sym_r_SQUOTE] = ACTIONS(1057), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1055), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1055), + [anon_sym_LBRACE] = ACTIONS(1055), + [anon_sym_RBRACE] = ACTIONS(1055), + [anon_sym_LBRACK] = ACTIONS(1055), + [anon_sym_null] = ACTIONS(1057), + [anon_sym_LPAREN] = ACTIONS(1055), + [anon_sym_RPAREN] = ACTIONS(1055), + [anon_sym_throw] = ACTIONS(1057), + [anon_sym_LT] = ACTIONS(1055), + [sym_increment_operator] = ACTIONS(1055), + [sym_minus_operator] = ACTIONS(1057), + [anon_sym_BANG] = ACTIONS(1055), + [anon_sym_TILDE] = ACTIONS(1055), + [anon_sym_await] = ACTIONS(1057), + [anon_sym_SEMI] = ACTIONS(1055), + [anon_sym_switch] = ACTIONS(1057), + [anon_sym_default] = ACTIONS(1057), + [anon_sym_do] = ACTIONS(1057), + [anon_sym_while] = ACTIONS(1057), + [anon_sym_continue] = ACTIONS(1057), + [anon_sym_yield] = ACTIONS(1057), + [anon_sym_return] = ACTIONS(1057), + [anon_sym_try] = ACTIONS(1057), + [anon_sym_if] = ACTIONS(1057), + [anon_sym_case] = ACTIONS(1057), + [anon_sym_else] = ACTIONS(1057), + [anon_sym_for] = ACTIONS(1057), + [anon_sym_AT] = ACTIONS(1055), + [anon_sym_enum] = ACTIONS(1057), + [anon_sym_final] = ACTIONS(1057), + [anon_sym_inline] = ACTIONS(1057), + [anon_sym_class] = ACTIONS(1057), + [anon_sym_extension] = ACTIONS(1057), + [sym_void_type] = ACTIONS(1057), + [anon_sym_var] = ACTIONS(1057), + [sym_break_builtin] = ACTIONS(1057), + [sym_assert_builtin] = ACTIONS(1057), + [sym_rethrow_builtin] = ACTIONS(1057), + [anon_sym_covariant] = ACTIONS(1057), + [anon_sym_factory] = ACTIONS(1057), + [anon_sym_Function] = ACTIONS(1057), + [anon_sym_get] = ACTIONS(1057), + [anon_sym_interface] = ACTIONS(1057), + [anon_sym_base] = ACTIONS(1057), + [anon_sym_abstract] = ACTIONS(1057), + [anon_sym_sealed] = ACTIONS(1057), + [anon_sym_operator] = ACTIONS(1057), + [anon_sym_mixin] = ACTIONS(1057), + [anon_sym_set] = ACTIONS(1057), + [anon_sym_static] = ACTIONS(1057), + [anon_sym_typedef] = ACTIONS(1057), + [anon_sym_new] = ACTIONS(1057), + [sym_const_builtin] = ACTIONS(1057), + [anon_sym_late] = ACTIONS(1057), + [anon_sym_external] = ACTIONS(1057), + [anon_sym_this] = ACTIONS(1057), + [anon_sym_super] = ACTIONS(1057), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(446)] = { + [sym_comment] = STATE(446), + [sym_documentation_comment] = STATE(446), + [ts_builtin_sym_end] = ACTIONS(1059), + [sym_identifier] = ACTIONS(1061), + [anon_sym_POUND] = ACTIONS(1059), + [sym_decimal_integer_literal] = ACTIONS(1061), + [sym_hex_integer_literal] = ACTIONS(1059), + [sym_decimal_floating_point_literal] = ACTIONS(1061), + [anon_sym_true] = ACTIONS(1061), + [anon_sym_false] = ACTIONS(1061), + [anon_sym_DQUOTE] = ACTIONS(1061), + [anon_sym_SQUOTE] = ACTIONS(1061), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1059), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1059), + [anon_sym_r_DQUOTE] = ACTIONS(1061), + [anon_sym_r_SQUOTE] = ACTIONS(1061), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1059), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1059), + [anon_sym_LBRACE] = ACTIONS(1059), + [anon_sym_RBRACE] = ACTIONS(1059), + [anon_sym_LBRACK] = ACTIONS(1059), + [anon_sym_null] = ACTIONS(1061), + [anon_sym_LPAREN] = ACTIONS(1059), + [anon_sym_throw] = ACTIONS(1061), + [anon_sym_LT] = ACTIONS(1059), + [sym_increment_operator] = ACTIONS(1059), + [sym_minus_operator] = ACTIONS(1061), + [anon_sym_BANG] = ACTIONS(1059), + [anon_sym_TILDE] = ACTIONS(1059), + [anon_sym_await] = ACTIONS(1061), + [anon_sym_switch] = ACTIONS(1061), + [anon_sym_default] = ACTIONS(1061), + [anon_sym_do] = ACTIONS(1061), + [anon_sym_while] = ACTIONS(1061), + [anon_sym_continue] = ACTIONS(1061), + [anon_sym_yield] = ACTIONS(1061), + [anon_sym_return] = ACTIONS(1061), + [anon_sym_try] = ACTIONS(1061), + [anon_sym_if] = ACTIONS(1061), + [anon_sym_case] = ACTIONS(1061), + [anon_sym_else] = ACTIONS(1061), + [anon_sym_for] = ACTIONS(1061), + [anon_sym_AT] = ACTIONS(1059), + [anon_sym_enum] = ACTIONS(1061), + [anon_sym_final] = ACTIONS(1061), + [anon_sym_inline] = ACTIONS(1061), + [anon_sym_class] = ACTIONS(1061), + [anon_sym_extension] = ACTIONS(1061), + [sym_void_type] = ACTIONS(1061), + [anon_sym_var] = ACTIONS(1061), + [sym_break_builtin] = ACTIONS(1061), + [sym_assert_builtin] = ACTIONS(1061), + [sym_rethrow_builtin] = ACTIONS(1061), + [anon_sym_covariant] = ACTIONS(1061), + [anon_sym_factory] = ACTIONS(1061), + [anon_sym_Function] = ACTIONS(1061), + [anon_sym_get] = ACTIONS(1061), + [anon_sym_interface] = ACTIONS(1061), + [anon_sym_base] = ACTIONS(1061), + [anon_sym_abstract] = ACTIONS(1061), + [anon_sym_sealed] = ACTIONS(1061), + [anon_sym_operator] = ACTIONS(1061), + [anon_sym_mixin] = ACTIONS(1061), + [anon_sym_set] = ACTIONS(1061), + [anon_sym_static] = ACTIONS(1061), + [anon_sym_typedef] = ACTIONS(1061), + [anon_sym_new] = ACTIONS(1061), + [sym_const_builtin] = ACTIONS(1061), + [anon_sym_late] = ACTIONS(1061), + [anon_sym_external] = ACTIONS(1061), + [anon_sym_this] = ACTIONS(1061), + [anon_sym_super] = ACTIONS(1061), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(447)] = { + [sym_comment] = STATE(447), + [sym_documentation_comment] = STATE(447), + [ts_builtin_sym_end] = ACTIONS(1063), + [sym_identifier] = ACTIONS(1065), + [anon_sym_POUND] = ACTIONS(1063), + [sym_decimal_integer_literal] = ACTIONS(1065), + [sym_hex_integer_literal] = ACTIONS(1063), + [sym_decimal_floating_point_literal] = ACTIONS(1065), + [anon_sym_true] = ACTIONS(1065), + [anon_sym_false] = ACTIONS(1065), + [anon_sym_DQUOTE] = ACTIONS(1065), + [anon_sym_SQUOTE] = ACTIONS(1065), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1063), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1063), + [anon_sym_r_DQUOTE] = ACTIONS(1065), + [anon_sym_r_SQUOTE] = ACTIONS(1065), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1063), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1063), + [anon_sym_LBRACE] = ACTIONS(1063), + [anon_sym_RBRACE] = ACTIONS(1063), + [anon_sym_LBRACK] = ACTIONS(1063), + [anon_sym_null] = ACTIONS(1065), + [anon_sym_LPAREN] = ACTIONS(1063), + [anon_sym_throw] = ACTIONS(1065), + [anon_sym_LT] = ACTIONS(1063), + [sym_increment_operator] = ACTIONS(1063), + [sym_minus_operator] = ACTIONS(1065), + [anon_sym_BANG] = ACTIONS(1063), + [anon_sym_TILDE] = ACTIONS(1063), + [anon_sym_await] = ACTIONS(1065), + [anon_sym_switch] = ACTIONS(1065), + [anon_sym_default] = ACTIONS(1065), + [anon_sym_do] = ACTIONS(1065), + [anon_sym_while] = ACTIONS(1065), + [anon_sym_continue] = ACTIONS(1065), + [anon_sym_yield] = ACTIONS(1065), + [anon_sym_return] = ACTIONS(1065), + [anon_sym_try] = ACTIONS(1065), + [anon_sym_if] = ACTIONS(1065), + [anon_sym_case] = ACTIONS(1065), + [anon_sym_else] = ACTIONS(1065), + [anon_sym_for] = ACTIONS(1065), + [anon_sym_AT] = ACTIONS(1063), + [anon_sym_enum] = ACTIONS(1065), + [anon_sym_final] = ACTIONS(1065), + [anon_sym_inline] = ACTIONS(1065), + [anon_sym_class] = ACTIONS(1065), + [anon_sym_extension] = ACTIONS(1065), + [sym_void_type] = ACTIONS(1065), + [anon_sym_var] = ACTIONS(1065), + [sym_break_builtin] = ACTIONS(1065), + [sym_assert_builtin] = ACTIONS(1065), + [sym_rethrow_builtin] = ACTIONS(1065), + [anon_sym_covariant] = ACTIONS(1065), + [anon_sym_factory] = ACTIONS(1065), + [anon_sym_Function] = ACTIONS(1065), + [anon_sym_get] = ACTIONS(1065), + [anon_sym_interface] = ACTIONS(1065), + [anon_sym_base] = ACTIONS(1065), + [anon_sym_abstract] = ACTIONS(1065), + [anon_sym_sealed] = ACTIONS(1065), + [anon_sym_operator] = ACTIONS(1065), + [anon_sym_mixin] = ACTIONS(1065), + [anon_sym_set] = ACTIONS(1065), + [anon_sym_static] = ACTIONS(1065), + [anon_sym_typedef] = ACTIONS(1065), + [anon_sym_new] = ACTIONS(1065), + [sym_const_builtin] = ACTIONS(1065), + [anon_sym_late] = ACTIONS(1065), + [anon_sym_external] = ACTIONS(1065), + [anon_sym_this] = ACTIONS(1065), + [anon_sym_super] = ACTIONS(1065), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(448)] = { + [sym_comment] = STATE(448), + [sym_documentation_comment] = STATE(448), + [ts_builtin_sym_end] = ACTIONS(1067), + [sym_identifier] = ACTIONS(1069), + [anon_sym_POUND] = ACTIONS(1067), + [sym_decimal_integer_literal] = ACTIONS(1069), + [sym_hex_integer_literal] = ACTIONS(1067), + [sym_decimal_floating_point_literal] = ACTIONS(1069), + [anon_sym_true] = ACTIONS(1069), + [anon_sym_false] = ACTIONS(1069), + [anon_sym_DQUOTE] = ACTIONS(1069), + [anon_sym_SQUOTE] = ACTIONS(1069), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1067), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1067), + [anon_sym_r_DQUOTE] = ACTIONS(1069), + [anon_sym_r_SQUOTE] = ACTIONS(1069), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1067), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1067), + [anon_sym_LBRACE] = ACTIONS(1067), + [anon_sym_RBRACE] = ACTIONS(1067), + [anon_sym_LBRACK] = ACTIONS(1067), + [anon_sym_null] = ACTIONS(1069), + [anon_sym_LPAREN] = ACTIONS(1067), + [anon_sym_throw] = ACTIONS(1069), + [anon_sym_LT] = ACTIONS(1067), + [sym_increment_operator] = ACTIONS(1067), + [sym_minus_operator] = ACTIONS(1069), + [anon_sym_BANG] = ACTIONS(1067), + [anon_sym_TILDE] = ACTIONS(1067), + [anon_sym_await] = ACTIONS(1069), + [anon_sym_switch] = ACTIONS(1069), + [anon_sym_default] = ACTIONS(1069), + [anon_sym_do] = ACTIONS(1069), + [anon_sym_while] = ACTIONS(1069), + [anon_sym_continue] = ACTIONS(1069), + [anon_sym_yield] = ACTIONS(1069), + [anon_sym_return] = ACTIONS(1069), + [anon_sym_try] = ACTIONS(1069), + [anon_sym_if] = ACTIONS(1069), + [anon_sym_case] = ACTIONS(1069), + [anon_sym_else] = ACTIONS(1069), + [anon_sym_for] = ACTIONS(1069), + [anon_sym_AT] = ACTIONS(1067), + [anon_sym_enum] = ACTIONS(1069), + [anon_sym_final] = ACTIONS(1069), + [anon_sym_inline] = ACTIONS(1069), + [anon_sym_class] = ACTIONS(1069), + [anon_sym_extension] = ACTIONS(1069), + [sym_void_type] = ACTIONS(1069), + [anon_sym_var] = ACTIONS(1069), + [sym_break_builtin] = ACTIONS(1069), + [sym_assert_builtin] = ACTIONS(1069), + [sym_rethrow_builtin] = ACTIONS(1069), + [anon_sym_covariant] = ACTIONS(1069), + [anon_sym_factory] = ACTIONS(1069), + [anon_sym_Function] = ACTIONS(1069), + [anon_sym_get] = ACTIONS(1069), + [anon_sym_interface] = ACTIONS(1069), + [anon_sym_base] = ACTIONS(1069), + [anon_sym_abstract] = ACTIONS(1069), + [anon_sym_sealed] = ACTIONS(1069), + [anon_sym_operator] = ACTIONS(1069), + [anon_sym_mixin] = ACTIONS(1069), + [anon_sym_set] = ACTIONS(1069), + [anon_sym_static] = ACTIONS(1069), + [anon_sym_typedef] = ACTIONS(1069), + [anon_sym_new] = ACTIONS(1069), + [sym_const_builtin] = ACTIONS(1069), + [anon_sym_late] = ACTIONS(1069), + [anon_sym_external] = ACTIONS(1069), + [anon_sym_this] = ACTIONS(1069), + [anon_sym_super] = ACTIONS(1069), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(449)] = { + [sym_comment] = STATE(449), + [sym_documentation_comment] = STATE(449), + [ts_builtin_sym_end] = ACTIONS(1071), + [sym_identifier] = ACTIONS(1073), + [anon_sym_POUND] = ACTIONS(1071), + [sym_decimal_integer_literal] = ACTIONS(1073), + [sym_hex_integer_literal] = ACTIONS(1071), + [sym_decimal_floating_point_literal] = ACTIONS(1073), + [anon_sym_true] = ACTIONS(1073), + [anon_sym_false] = ACTIONS(1073), + [anon_sym_DQUOTE] = ACTIONS(1073), + [anon_sym_SQUOTE] = ACTIONS(1073), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1071), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1071), + [anon_sym_r_DQUOTE] = ACTIONS(1073), + [anon_sym_r_SQUOTE] = ACTIONS(1073), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1071), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1071), + [anon_sym_LBRACE] = ACTIONS(1071), + [anon_sym_RBRACE] = ACTIONS(1071), + [anon_sym_LBRACK] = ACTIONS(1071), + [anon_sym_null] = ACTIONS(1073), + [anon_sym_LPAREN] = ACTIONS(1071), + [anon_sym_throw] = ACTIONS(1073), + [anon_sym_LT] = ACTIONS(1071), + [sym_increment_operator] = ACTIONS(1071), + [sym_minus_operator] = ACTIONS(1073), + [anon_sym_BANG] = ACTIONS(1071), + [anon_sym_TILDE] = ACTIONS(1071), + [anon_sym_await] = ACTIONS(1073), + [anon_sym_switch] = ACTIONS(1073), + [anon_sym_default] = ACTIONS(1073), + [anon_sym_do] = ACTIONS(1073), + [anon_sym_while] = ACTIONS(1073), + [anon_sym_continue] = ACTIONS(1073), + [anon_sym_yield] = ACTIONS(1073), + [anon_sym_return] = ACTIONS(1073), + [anon_sym_try] = ACTIONS(1073), + [anon_sym_if] = ACTIONS(1073), + [anon_sym_case] = ACTIONS(1073), + [anon_sym_else] = ACTIONS(1073), + [anon_sym_for] = ACTIONS(1073), + [anon_sym_AT] = ACTIONS(1071), + [anon_sym_enum] = ACTIONS(1073), + [anon_sym_final] = ACTIONS(1073), + [anon_sym_inline] = ACTIONS(1073), + [anon_sym_class] = ACTIONS(1073), + [anon_sym_extension] = ACTIONS(1073), + [sym_void_type] = ACTIONS(1073), + [anon_sym_var] = ACTIONS(1073), + [sym_break_builtin] = ACTIONS(1073), + [sym_assert_builtin] = ACTIONS(1073), + [sym_rethrow_builtin] = ACTIONS(1073), + [anon_sym_covariant] = ACTIONS(1073), + [anon_sym_factory] = ACTIONS(1073), + [anon_sym_Function] = ACTIONS(1073), + [anon_sym_get] = ACTIONS(1073), + [anon_sym_interface] = ACTIONS(1073), + [anon_sym_base] = ACTIONS(1073), + [anon_sym_abstract] = ACTIONS(1073), + [anon_sym_sealed] = ACTIONS(1073), + [anon_sym_operator] = ACTIONS(1073), + [anon_sym_mixin] = ACTIONS(1073), + [anon_sym_set] = ACTIONS(1073), + [anon_sym_static] = ACTIONS(1073), + [anon_sym_typedef] = ACTIONS(1073), + [anon_sym_new] = ACTIONS(1073), + [sym_const_builtin] = ACTIONS(1073), + [anon_sym_late] = ACTIONS(1073), + [anon_sym_external] = ACTIONS(1073), + [anon_sym_this] = ACTIONS(1073), + [anon_sym_super] = ACTIONS(1073), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(450)] = { + [sym__bool_literal] = STATE(2419), + [sym__numeric_literal] = STATE(2419), + [sym__literal] = STATE(2420), + [sym_symbol_literal] = STATE(2419), + [sym_true] = STATE(2428), + [sym_false] = STATE(2428), + [sym_string_literal] = STATE(2419), + [sym__string_literal_double_quotes] = STATE(2026), + [sym__string_literal_single_quotes] = STATE(2026), + [sym__string_literal_double_quotes_multiple] = STATE(2026), + [sym__string_literal_single_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_double_quotes] = STATE(2026), + [sym__raw_string_literal_single_quotes] = STATE(2026), + [sym__raw_string_literal_double_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_single_quotes_multiple] = STATE(2026), + [sym_list_literal] = STATE(2419), + [sym_set_or_map_literal] = STATE(2419), + [sym_null_literal] = STATE(2419), + [sym_record_literal] = STATE(2419), + [sym__record_literal_no_const] = STATE(2430), + [sym_assignable_expression] = STATE(1489), + [sym_function_expression] = STATE(2420), + [sym_new_expression] = STATE(2420), + [sym_const_object_expression] = STATE(2420), + [sym__primary] = STATE(1940), + [sym_parenthesized_expression] = STATE(2420), + [sym_constructor_invocation] = STATE(1940), + [sym_constructor_tearoff] = STATE(2420), + [sym_type_arguments] = STATE(3288), + [sym_switch_expression] = STATE(2420), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2822), + [sym__formal_parameter_part] = STATE(2393), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(2412), + [sym__set] = STATE(2412), + [sym__new_builtin] = STATE(2104), + [sym_this] = STATE(2420), + [sym_super] = STATE(2699), + [sym_comment] = STATE(450), + [sym_documentation_comment] = STATE(450), + [aux_sym_string_literal_repeat1] = STATE(1735), + [sym_identifier] = ACTIONS(1075), + [anon_sym_POUND] = ACTIONS(1077), + [sym_decimal_integer_literal] = ACTIONS(1079), + [sym_hex_integer_literal] = ACTIONS(1081), + [sym_decimal_floating_point_literal] = ACTIONS(1079), + [anon_sym_true] = ACTIONS(1083), + [anon_sym_false] = ACTIONS(1085), + [anon_sym_DQUOTE] = ACTIONS(1087), + [anon_sym_SQUOTE] = ACTIONS(1089), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1091), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1093), + [anon_sym_r_DQUOTE] = ACTIONS(1095), + [anon_sym_r_SQUOTE] = ACTIONS(1097), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1099), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1101), + [anon_sym_LBRACE] = ACTIONS(1103), + [anon_sym_LBRACK] = ACTIONS(1105), + [anon_sym_null] = ACTIONS(1107), + [anon_sym_LPAREN] = ACTIONS(1109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_switch] = ACTIONS(1111), + [anon_sym_get] = ACTIONS(47), + [anon_sym_set] = ACTIONS(61), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(1113), + [anon_sym_this] = ACTIONS(1115), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(451)] = { + [sym__bool_literal] = STATE(2419), + [sym__numeric_literal] = STATE(2419), + [sym__literal] = STATE(2420), + [sym_symbol_literal] = STATE(2419), + [sym_true] = STATE(2428), + [sym_false] = STATE(2428), + [sym_string_literal] = STATE(2419), + [sym__string_literal_double_quotes] = STATE(2026), + [sym__string_literal_single_quotes] = STATE(2026), + [sym__string_literal_double_quotes_multiple] = STATE(2026), + [sym__string_literal_single_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_double_quotes] = STATE(2026), + [sym__raw_string_literal_single_quotes] = STATE(2026), + [sym__raw_string_literal_double_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_single_quotes_multiple] = STATE(2026), + [sym_list_literal] = STATE(2419), + [sym_set_or_map_literal] = STATE(2419), + [sym_null_literal] = STATE(2419), + [sym_record_literal] = STATE(2419), + [sym__record_literal_no_const] = STATE(2430), + [sym_assignable_expression] = STATE(1106), + [sym_function_expression] = STATE(2420), + [sym_new_expression] = STATE(2420), + [sym_const_object_expression] = STATE(2420), + [sym__primary] = STATE(1951), + [sym_parenthesized_expression] = STATE(2420), + [sym_constructor_invocation] = STATE(1951), + [sym_constructor_tearoff] = STATE(2420), + [sym_type_arguments] = STATE(3288), + [sym_switch_expression] = STATE(2420), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2822), + [sym__formal_parameter_part] = STATE(2393), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(2412), + [sym__set] = STATE(2412), + [sym__new_builtin] = STATE(2104), + [sym_this] = STATE(2420), + [sym_super] = STATE(2649), + [sym_comment] = STATE(451), + [sym_documentation_comment] = STATE(451), + [aux_sym_string_literal_repeat1] = STATE(1735), + [sym_identifier] = ACTIONS(1117), + [anon_sym_POUND] = ACTIONS(1077), + [sym_decimal_integer_literal] = ACTIONS(1079), + [sym_hex_integer_literal] = ACTIONS(1081), + [sym_decimal_floating_point_literal] = ACTIONS(1079), + [anon_sym_true] = ACTIONS(1083), + [anon_sym_false] = ACTIONS(1085), + [anon_sym_DQUOTE] = ACTIONS(1087), + [anon_sym_SQUOTE] = ACTIONS(1089), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1091), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1093), + [anon_sym_r_DQUOTE] = ACTIONS(1095), + [anon_sym_r_SQUOTE] = ACTIONS(1097), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1099), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1101), + [anon_sym_LBRACE] = ACTIONS(1103), + [anon_sym_LBRACK] = ACTIONS(1105), + [anon_sym_null] = ACTIONS(1107), + [anon_sym_LPAREN] = ACTIONS(1109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_switch] = ACTIONS(1111), + [anon_sym_get] = ACTIONS(47), + [anon_sym_set] = ACTIONS(61), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(1113), + [anon_sym_this] = ACTIONS(1115), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(452)] = { + [sym__bool_literal] = STATE(2419), + [sym__numeric_literal] = STATE(2419), + [sym__literal] = STATE(2420), + [sym_symbol_literal] = STATE(2419), + [sym_true] = STATE(2428), + [sym_false] = STATE(2428), + [sym_string_literal] = STATE(2419), + [sym__string_literal_double_quotes] = STATE(2026), + [sym__string_literal_single_quotes] = STATE(2026), + [sym__string_literal_double_quotes_multiple] = STATE(2026), + [sym__string_literal_single_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_double_quotes] = STATE(2026), + [sym__raw_string_literal_single_quotes] = STATE(2026), + [sym__raw_string_literal_double_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_single_quotes_multiple] = STATE(2026), + [sym_list_literal] = STATE(2419), + [sym_set_or_map_literal] = STATE(2419), + [sym_null_literal] = STATE(2419), + [sym_record_literal] = STATE(2419), + [sym__record_literal_no_const] = STATE(2430), + [sym_assignable_expression] = STATE(1403), + [sym_function_expression] = STATE(2420), + [sym_new_expression] = STATE(2420), + [sym_const_object_expression] = STATE(2420), + [sym__primary] = STATE(1950), + [sym_parenthesized_expression] = STATE(2420), + [sym_constructor_invocation] = STATE(1950), + [sym_constructor_tearoff] = STATE(2420), + [sym_type_arguments] = STATE(3288), + [sym_switch_expression] = STATE(2420), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2822), + [sym__formal_parameter_part] = STATE(2393), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(2412), + [sym__set] = STATE(2412), + [sym__new_builtin] = STATE(2104), + [sym_this] = STATE(2420), + [sym_super] = STATE(2645), + [sym_comment] = STATE(452), + [sym_documentation_comment] = STATE(452), + [aux_sym_string_literal_repeat1] = STATE(1735), + [sym_identifier] = ACTIONS(1119), + [anon_sym_POUND] = ACTIONS(1077), + [sym_decimal_integer_literal] = ACTIONS(1079), + [sym_hex_integer_literal] = ACTIONS(1081), + [sym_decimal_floating_point_literal] = ACTIONS(1079), + [anon_sym_true] = ACTIONS(1083), + [anon_sym_false] = ACTIONS(1085), + [anon_sym_DQUOTE] = ACTIONS(1087), + [anon_sym_SQUOTE] = ACTIONS(1089), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1091), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1093), + [anon_sym_r_DQUOTE] = ACTIONS(1095), + [anon_sym_r_SQUOTE] = ACTIONS(1097), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1099), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1101), + [anon_sym_LBRACE] = ACTIONS(1103), + [anon_sym_LBRACK] = ACTIONS(1105), + [anon_sym_null] = ACTIONS(1107), + [anon_sym_LPAREN] = ACTIONS(1109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_switch] = ACTIONS(1111), + [anon_sym_get] = ACTIONS(47), + [anon_sym_set] = ACTIONS(61), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(1113), + [anon_sym_this] = ACTIONS(1115), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(453)] = { + [sym__bool_literal] = STATE(2419), + [sym__numeric_literal] = STATE(2419), + [sym__literal] = STATE(2420), + [sym_symbol_literal] = STATE(2419), + [sym_true] = STATE(2428), + [sym_false] = STATE(2428), + [sym_string_literal] = STATE(2419), + [sym__string_literal_double_quotes] = STATE(2026), + [sym__string_literal_single_quotes] = STATE(2026), + [sym__string_literal_double_quotes_multiple] = STATE(2026), + [sym__string_literal_single_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_double_quotes] = STATE(2026), + [sym__raw_string_literal_single_quotes] = STATE(2026), + [sym__raw_string_literal_double_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_single_quotes_multiple] = STATE(2026), + [sym_list_literal] = STATE(2419), + [sym_set_or_map_literal] = STATE(2419), + [sym_null_literal] = STATE(2419), + [sym_record_literal] = STATE(2419), + [sym__record_literal_no_const] = STATE(2430), + [sym_assignable_expression] = STATE(1327), + [sym_function_expression] = STATE(2420), + [sym_new_expression] = STATE(2420), + [sym_const_object_expression] = STATE(2420), + [sym__primary] = STATE(1942), + [sym_parenthesized_expression] = STATE(2420), + [sym_constructor_invocation] = STATE(1942), + [sym_constructor_tearoff] = STATE(2420), + [sym_type_arguments] = STATE(3288), + [sym_switch_expression] = STATE(2420), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2822), + [sym__formal_parameter_part] = STATE(2393), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(2412), + [sym__set] = STATE(2412), + [sym__new_builtin] = STATE(2104), + [sym_this] = STATE(2420), + [sym_super] = STATE(2629), + [sym_comment] = STATE(453), + [sym_documentation_comment] = STATE(453), + [aux_sym_string_literal_repeat1] = STATE(1735), + [sym_identifier] = ACTIONS(1121), + [anon_sym_POUND] = ACTIONS(1077), + [sym_decimal_integer_literal] = ACTIONS(1079), + [sym_hex_integer_literal] = ACTIONS(1081), + [sym_decimal_floating_point_literal] = ACTIONS(1079), + [anon_sym_true] = ACTIONS(1083), + [anon_sym_false] = ACTIONS(1085), + [anon_sym_DQUOTE] = ACTIONS(1087), + [anon_sym_SQUOTE] = ACTIONS(1089), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1091), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1093), + [anon_sym_r_DQUOTE] = ACTIONS(1095), + [anon_sym_r_SQUOTE] = ACTIONS(1097), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1099), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1101), + [anon_sym_LBRACE] = ACTIONS(1103), + [anon_sym_LBRACK] = ACTIONS(1105), + [anon_sym_null] = ACTIONS(1107), + [anon_sym_LPAREN] = ACTIONS(1109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_switch] = ACTIONS(1111), + [anon_sym_get] = ACTIONS(47), + [anon_sym_set] = ACTIONS(61), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(1113), + [anon_sym_this] = ACTIONS(1115), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(454)] = { + [sym__bool_literal] = STATE(2419), + [sym__numeric_literal] = STATE(2419), + [sym__literal] = STATE(2420), + [sym_symbol_literal] = STATE(2419), + [sym_true] = STATE(2428), + [sym_false] = STATE(2428), + [sym_string_literal] = STATE(2419), + [sym__string_literal_double_quotes] = STATE(2026), + [sym__string_literal_single_quotes] = STATE(2026), + [sym__string_literal_double_quotes_multiple] = STATE(2026), + [sym__string_literal_single_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_double_quotes] = STATE(2026), + [sym__raw_string_literal_single_quotes] = STATE(2026), + [sym__raw_string_literal_double_quotes_multiple] = STATE(2026), + [sym__raw_string_literal_single_quotes_multiple] = STATE(2026), + [sym_list_literal] = STATE(2419), + [sym_set_or_map_literal] = STATE(2419), + [sym_null_literal] = STATE(2419), + [sym_record_literal] = STATE(2419), + [sym__record_literal_no_const] = STATE(2430), + [sym_assignable_expression] = STATE(913), + [sym_function_expression] = STATE(2420), + [sym_new_expression] = STATE(2420), + [sym_const_object_expression] = STATE(2420), + [sym__primary] = STATE(1946), + [sym_parenthesized_expression] = STATE(2420), + [sym_constructor_invocation] = STATE(1946), + [sym_constructor_tearoff] = STATE(2420), + [sym_type_arguments] = STATE(3288), + [sym_switch_expression] = STATE(2420), + [sym_type_parameters] = STATE(2898), + [sym__type_name] = STATE(2822), + [sym__formal_parameter_part] = STATE(2393), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym__get] = STATE(2412), + [sym__set] = STATE(2412), + [sym__new_builtin] = STATE(2104), + [sym_this] = STATE(2420), + [sym_super] = STATE(2638), + [sym_comment] = STATE(454), + [sym_documentation_comment] = STATE(454), + [aux_sym_string_literal_repeat1] = STATE(1735), + [sym_identifier] = ACTIONS(1123), + [anon_sym_POUND] = ACTIONS(1077), + [sym_decimal_integer_literal] = ACTIONS(1079), + [sym_hex_integer_literal] = ACTIONS(1081), + [sym_decimal_floating_point_literal] = ACTIONS(1079), + [anon_sym_true] = ACTIONS(1083), + [anon_sym_false] = ACTIONS(1085), + [anon_sym_DQUOTE] = ACTIONS(1087), + [anon_sym_SQUOTE] = ACTIONS(1089), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1091), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1093), + [anon_sym_r_DQUOTE] = ACTIONS(1095), + [anon_sym_r_SQUOTE] = ACTIONS(1097), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1099), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1101), + [anon_sym_LBRACE] = ACTIONS(1103), + [anon_sym_LBRACK] = ACTIONS(1105), + [anon_sym_null] = ACTIONS(1107), + [anon_sym_LPAREN] = ACTIONS(1109), + [anon_sym_LT] = ACTIONS(111), + [anon_sym_switch] = ACTIONS(1111), + [anon_sym_get] = ACTIONS(47), + [anon_sym_set] = ACTIONS(61), + [anon_sym_new] = ACTIONS(159), + [sym_const_builtin] = ACTIONS(1113), + [anon_sym_this] = ACTIONS(1115), + [anon_sym_super] = ACTIONS(165), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(455)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(672), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(455), + [sym_documentation_comment] = STATE(455), + [aux_sym_program_repeat2] = STATE(1417), + [aux_sym_program_repeat3] = STATE(462), + [aux_sym_program_repeat4] = STATE(474), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1125), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(456)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(672), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(456), + [sym_documentation_comment] = STATE(456), + [aux_sym_program_repeat2] = STATE(1417), + [aux_sym_program_repeat3] = STATE(461), + [aux_sym_program_repeat4] = STATE(481), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(457)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(672), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(457), + [sym_documentation_comment] = STATE(457), + [aux_sym_program_repeat2] = STATE(1417), + [aux_sym_program_repeat3] = STATE(464), + [aux_sym_program_repeat4] = STATE(477), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1049), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(458)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_directive] = STATE(1705), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(672), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(458), + [sym_documentation_comment] = STATE(458), + [aux_sym_program_repeat2] = STATE(1417), + [aux_sym_program_repeat3] = STATE(465), + [aux_sym_program_repeat4] = STATE(476), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1047), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_part] = ACTIONS(21), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(459)] = { + [sym__assignment_operator] = STATE(289), + [sym_arguments] = STATE(582), + [sym__cascade_subsection] = STATE(586), + [sym__cascade_assignment_section] = STATE(954), + [sym_index_selector] = STATE(601), + [sym_argument_part] = STATE(587), + [sym_unconditional_assignable_selector] = STATE(602), + [sym_conditional_assignable_selector] = STATE(602), + [sym__assignable_selector] = STATE(495), + [sym_type_arguments] = STATE(3255), + [sym_comment] = STATE(459), + [sym_documentation_comment] = STATE(459), + [aux_sym_cascade_section_repeat1] = STATE(507), + [aux_sym_cascade_section_repeat2] = STATE(470), + [anon_sym_RBRACE] = ACTIONS(1127), + [anon_sym_LBRACK] = ACTIONS(1127), + [anon_sym_COMMA] = ACTIONS(1127), + [anon_sym_RBRACK] = ACTIONS(1127), + [anon_sym_COLON] = ACTIONS(1127), + [anon_sym_LPAREN] = ACTIONS(1127), + [anon_sym_RPAREN] = ACTIONS(1127), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1133), + [anon_sym_QMARK] = ACTIONS(1133), + [sym_equality_operator] = ACTIONS(1127), + [anon_sym_LT] = ACTIONS(1133), + [anon_sym_GT] = ACTIONS(1133), + [anon_sym_LT_EQ] = ACTIONS(1127), + [anon_sym_GT_EQ] = ACTIONS(1127), + [anon_sym_PIPE] = ACTIONS(1133), + [anon_sym_CARET] = ACTIONS(1133), + [anon_sym_AMP] = ACTIONS(1133), + [anon_sym_LT_LT] = ACTIONS(1133), + [anon_sym_GT_GT] = ACTIONS(1133), + [anon_sym_GT_GT_GT] = ACTIONS(1133), + [sym__additive_operator] = ACTIONS(1133), + [anon_sym_STAR] = ACTIONS(1133), + [anon_sym_SLASH] = ACTIONS(1133), + [anon_sym_PERCENT] = ACTIONS(1133), + [anon_sym_TILDE_SLASH] = ACTIONS(1133), + [anon_sym_BANG] = ACTIONS(1133), + [anon_sym_is] = ACTIONS(1127), + [anon_sym_as] = ACTIONS(1127), + [anon_sym_DOT] = ACTIONS(1133), + [anon_sym_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT] = ACTIONS(1133), + [anon_sym_SEMI] = ACTIONS(1127), + [anon_sym_EQ_GT] = ACTIONS(1127), + [anon_sym_when] = ACTIONS(1127), + [anon_sym_case] = ACTIONS(1127), + [anon_sym_else] = ACTIONS(1127), + [anon_sym_AMP_AMP] = ACTIONS(1127), + [anon_sym_PIPE_PIPE] = ACTIONS(1127), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(460)] = { + [sym__assignment_operator] = STATE(289), + [sym_arguments] = STATE(582), + [sym__cascade_subsection] = STATE(586), + [sym__cascade_assignment_section] = STATE(908), + [sym_index_selector] = STATE(601), + [sym_argument_part] = STATE(587), + [sym_unconditional_assignable_selector] = STATE(602), + [sym_conditional_assignable_selector] = STATE(602), + [sym__assignable_selector] = STATE(495), + [sym_type_arguments] = STATE(3255), + [sym_comment] = STATE(460), + [sym_documentation_comment] = STATE(460), + [aux_sym_cascade_section_repeat1] = STATE(459), + [aux_sym_cascade_section_repeat2] = STATE(471), + [anon_sym_RBRACE] = ACTIONS(1135), + [anon_sym_LBRACK] = ACTIONS(1135), + [anon_sym_COMMA] = ACTIONS(1135), + [anon_sym_RBRACK] = ACTIONS(1135), + [anon_sym_COLON] = ACTIONS(1135), + [anon_sym_LPAREN] = ACTIONS(1135), + [anon_sym_RPAREN] = ACTIONS(1135), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1137), + [anon_sym_QMARK] = ACTIONS(1137), + [sym_equality_operator] = ACTIONS(1135), + [anon_sym_LT] = ACTIONS(1137), + [anon_sym_GT] = ACTIONS(1137), + [anon_sym_LT_EQ] = ACTIONS(1135), + [anon_sym_GT_EQ] = ACTIONS(1135), + [anon_sym_PIPE] = ACTIONS(1137), + [anon_sym_CARET] = ACTIONS(1137), + [anon_sym_AMP] = ACTIONS(1137), + [anon_sym_LT_LT] = ACTIONS(1137), + [anon_sym_GT_GT] = ACTIONS(1137), + [anon_sym_GT_GT_GT] = ACTIONS(1137), + [sym__additive_operator] = ACTIONS(1137), + [anon_sym_STAR] = ACTIONS(1137), + [anon_sym_SLASH] = ACTIONS(1137), + [anon_sym_PERCENT] = ACTIONS(1137), + [anon_sym_TILDE_SLASH] = ACTIONS(1137), + [anon_sym_BANG] = ACTIONS(1137), + [anon_sym_is] = ACTIONS(1135), + [anon_sym_as] = ACTIONS(1135), + [anon_sym_DOT] = ACTIONS(1137), + [anon_sym_DOT_DOT] = ACTIONS(1135), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1135), + [anon_sym_QMARK_DOT] = ACTIONS(1137), + [anon_sym_SEMI] = ACTIONS(1135), + [anon_sym_EQ_GT] = ACTIONS(1135), + [anon_sym_when] = ACTIONS(1135), + [anon_sym_case] = ACTIONS(1135), + [anon_sym_else] = ACTIONS(1135), + [anon_sym_AMP_AMP] = ACTIONS(1135), + [anon_sym_PIPE_PIPE] = ACTIONS(1135), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(461)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(682), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(461), + [sym_documentation_comment] = STATE(461), + [aux_sym_program_repeat3] = STATE(1491), + [aux_sym_program_repeat4] = STATE(476), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1047), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(462)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(682), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(462), + [sym_documentation_comment] = STATE(462), + [aux_sym_program_repeat3] = STATE(1491), + [aux_sym_program_repeat4] = STATE(479), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1139), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(463)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(682), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(463), + [sym_documentation_comment] = STATE(463), + [aux_sym_program_repeat3] = STATE(1491), + [aux_sym_program_repeat4] = STATE(481), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(464)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(682), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(464), + [sym_documentation_comment] = STATE(464), + [aux_sym_program_repeat3] = STATE(1491), + [aux_sym_program_repeat4] = STATE(474), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1125), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(465)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1588), + [sym_part_of_directive] = STATE(1732), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(682), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(465), + [sym_documentation_comment] = STATE(465), + [aux_sym_program_repeat3] = STATE(1491), + [aux_sym_program_repeat4] = STATE(477), + [aux_sym__metadata_repeat1] = STATE(1484), + [ts_builtin_sym_end] = ACTIONS(1049), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(19), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [sym_part_of_builtin] = ACTIONS(41), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(466)] = { + [sym__assignment_operator] = STATE(288), + [sym_arguments] = STATE(657), + [sym__cascade_subsection] = STATE(644), + [sym__cascade_assignment_section] = STATE(1155), + [sym_index_selector] = STATE(640), + [sym_argument_part] = STATE(639), + [sym_unconditional_assignable_selector] = STATE(641), + [sym_conditional_assignable_selector] = STATE(641), + [sym__assignable_selector] = STATE(560), + [sym_type_arguments] = STATE(3121), + [sym_comment] = STATE(466), + [sym_documentation_comment] = STATE(466), + [aux_sym_cascade_section_repeat1] = STATE(469), + [aux_sym_cascade_section_repeat2] = STATE(487), + [anon_sym_LBRACE] = ACTIONS(1135), + [anon_sym_LBRACK] = ACTIONS(1135), + [anon_sym_COMMA] = ACTIONS(1135), + [anon_sym_LPAREN] = ACTIONS(1135), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1137), + [anon_sym_QMARK] = ACTIONS(1137), + [sym_equality_operator] = ACTIONS(1135), + [anon_sym_LT] = ACTIONS(1137), + [anon_sym_GT] = ACTIONS(1137), + [anon_sym_LT_EQ] = ACTIONS(1135), + [anon_sym_GT_EQ] = ACTIONS(1135), + [anon_sym_PIPE] = ACTIONS(1137), + [anon_sym_CARET] = ACTIONS(1137), + [anon_sym_AMP] = ACTIONS(1137), + [anon_sym_LT_LT] = ACTIONS(1137), + [anon_sym_GT_GT] = ACTIONS(1137), + [anon_sym_GT_GT_GT] = ACTIONS(1137), + [sym__additive_operator] = ACTIONS(1137), + [anon_sym_STAR] = ACTIONS(1137), + [anon_sym_SLASH] = ACTIONS(1137), + [anon_sym_PERCENT] = ACTIONS(1137), + [anon_sym_TILDE_SLASH] = ACTIONS(1137), + [anon_sym_BANG] = ACTIONS(1137), + [anon_sym_is] = ACTIONS(1135), + [anon_sym_as] = ACTIONS(1137), + [anon_sym_DOT] = ACTIONS(1137), + [anon_sym_DOT_DOT] = ACTIONS(1135), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1135), + [anon_sym_QMARK_DOT] = ACTIONS(1137), + [anon_sym_SEMI] = ACTIONS(1135), + [anon_sym_EQ_GT] = ACTIONS(1135), + [anon_sym_async] = ACTIONS(1137), + [anon_sym_async_STAR] = ACTIONS(1135), + [anon_sym_sync_STAR] = ACTIONS(1135), + [anon_sym_AMP_AMP] = ACTIONS(1135), + [anon_sym_PIPE_PIPE] = ACTIONS(1135), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(467)] = { + [sym__on_part] = STATE(493), + [sym_catch_clause] = STATE(3144), + [sym_finally_clause] = STATE(523), + [sym_comment] = STATE(467), + [sym_documentation_comment] = STATE(467), + [aux_sym_try_statement_repeat1] = STATE(468), + [sym_identifier] = ACTIONS(1141), + [anon_sym_POUND] = ACTIONS(1143), + [sym_decimal_integer_literal] = ACTIONS(1141), + [sym_hex_integer_literal] = ACTIONS(1143), + [sym_decimal_floating_point_literal] = ACTIONS(1141), + [anon_sym_true] = ACTIONS(1141), + [anon_sym_false] = ACTIONS(1141), + [anon_sym_DQUOTE] = ACTIONS(1141), + [anon_sym_SQUOTE] = ACTIONS(1141), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1143), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1143), + [anon_sym_r_DQUOTE] = ACTIONS(1141), + [anon_sym_r_SQUOTE] = ACTIONS(1141), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1143), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1143), + [anon_sym_LBRACE] = ACTIONS(1143), + [anon_sym_RBRACE] = ACTIONS(1143), + [anon_sym_LBRACK] = ACTIONS(1143), + [anon_sym_null] = ACTIONS(1141), + [anon_sym_LPAREN] = ACTIONS(1143), + [anon_sym_throw] = ACTIONS(1141), + [anon_sym_LT] = ACTIONS(1143), + [sym_increment_operator] = ACTIONS(1143), + [sym_minus_operator] = ACTIONS(1141), + [anon_sym_BANG] = ACTIONS(1143), + [anon_sym_TILDE] = ACTIONS(1143), + [anon_sym_await] = ACTIONS(1141), + [anon_sym_switch] = ACTIONS(1141), + [anon_sym_default] = ACTIONS(1141), + [anon_sym_do] = ACTIONS(1141), + [anon_sym_while] = ACTIONS(1141), + [anon_sym_continue] = ACTIONS(1141), + [anon_sym_yield] = ACTIONS(1141), + [anon_sym_return] = ACTIONS(1141), + [anon_sym_on] = ACTIONS(1145), + [anon_sym_try] = ACTIONS(1141), + [anon_sym_catch] = ACTIONS(1147), + [anon_sym_finally] = ACTIONS(1149), + [anon_sym_if] = ACTIONS(1141), + [anon_sym_case] = ACTIONS(1141), + [anon_sym_else] = ACTIONS(1141), + [anon_sym_for] = ACTIONS(1141), + [anon_sym_AT] = ACTIONS(1143), + [anon_sym_final] = ACTIONS(1141), + [sym_void_type] = ACTIONS(1141), + [anon_sym_var] = ACTIONS(1141), + [sym_break_builtin] = ACTIONS(1141), + [sym_assert_builtin] = ACTIONS(1141), + [sym_rethrow_builtin] = ACTIONS(1141), + [anon_sym_covariant] = ACTIONS(1141), + [anon_sym_Function] = ACTIONS(1141), + [anon_sym_get] = ACTIONS(1141), + [anon_sym_set] = ACTIONS(1141), + [anon_sym_new] = ACTIONS(1141), + [sym_const_builtin] = ACTIONS(1141), + [anon_sym_late] = ACTIONS(1141), + [anon_sym_this] = ACTIONS(1141), + [anon_sym_super] = ACTIONS(1141), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(468)] = { + [sym__on_part] = STATE(493), + [sym_catch_clause] = STATE(3144), + [sym_finally_clause] = STATE(520), + [sym_comment] = STATE(468), + [sym_documentation_comment] = STATE(468), + [aux_sym_try_statement_repeat1] = STATE(472), + [sym_identifier] = ACTIONS(1151), + [anon_sym_POUND] = ACTIONS(1153), + [sym_decimal_integer_literal] = ACTIONS(1151), + [sym_hex_integer_literal] = ACTIONS(1153), + [sym_decimal_floating_point_literal] = ACTIONS(1151), + [anon_sym_true] = ACTIONS(1151), + [anon_sym_false] = ACTIONS(1151), + [anon_sym_DQUOTE] = ACTIONS(1151), + [anon_sym_SQUOTE] = ACTIONS(1151), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1153), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1153), + [anon_sym_r_DQUOTE] = ACTIONS(1151), + [anon_sym_r_SQUOTE] = ACTIONS(1151), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1153), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1153), + [anon_sym_LBRACE] = ACTIONS(1153), + [anon_sym_RBRACE] = ACTIONS(1153), + [anon_sym_LBRACK] = ACTIONS(1153), + [anon_sym_null] = ACTIONS(1151), + [anon_sym_LPAREN] = ACTIONS(1153), + [anon_sym_throw] = ACTIONS(1151), + [anon_sym_LT] = ACTIONS(1153), + [sym_increment_operator] = ACTIONS(1153), + [sym_minus_operator] = ACTIONS(1151), + [anon_sym_BANG] = ACTIONS(1153), + [anon_sym_TILDE] = ACTIONS(1153), + [anon_sym_await] = ACTIONS(1151), + [anon_sym_switch] = ACTIONS(1151), + [anon_sym_default] = ACTIONS(1151), + [anon_sym_do] = ACTIONS(1151), + [anon_sym_while] = ACTIONS(1151), + [anon_sym_continue] = ACTIONS(1151), + [anon_sym_yield] = ACTIONS(1151), + [anon_sym_return] = ACTIONS(1151), + [anon_sym_on] = ACTIONS(1145), + [anon_sym_try] = ACTIONS(1151), + [anon_sym_catch] = ACTIONS(1147), + [anon_sym_finally] = ACTIONS(1149), + [anon_sym_if] = ACTIONS(1151), + [anon_sym_case] = ACTIONS(1151), + [anon_sym_else] = ACTIONS(1151), + [anon_sym_for] = ACTIONS(1151), + [anon_sym_AT] = ACTIONS(1153), + [anon_sym_final] = ACTIONS(1151), + [sym_void_type] = ACTIONS(1151), + [anon_sym_var] = ACTIONS(1151), + [sym_break_builtin] = ACTIONS(1151), + [sym_assert_builtin] = ACTIONS(1151), + [sym_rethrow_builtin] = ACTIONS(1151), + [anon_sym_covariant] = ACTIONS(1151), + [anon_sym_Function] = ACTIONS(1151), + [anon_sym_get] = ACTIONS(1151), + [anon_sym_set] = ACTIONS(1151), + [anon_sym_new] = ACTIONS(1151), + [sym_const_builtin] = ACTIONS(1151), + [anon_sym_late] = ACTIONS(1151), + [anon_sym_this] = ACTIONS(1151), + [anon_sym_super] = ACTIONS(1151), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(469)] = { + [sym__assignment_operator] = STATE(288), + [sym_arguments] = STATE(657), + [sym__cascade_subsection] = STATE(644), + [sym__cascade_assignment_section] = STATE(1116), + [sym_index_selector] = STATE(640), + [sym_argument_part] = STATE(639), + [sym_unconditional_assignable_selector] = STATE(641), + [sym_conditional_assignable_selector] = STATE(641), + [sym__assignable_selector] = STATE(560), + [sym_type_arguments] = STATE(3121), + [sym_comment] = STATE(469), + [sym_documentation_comment] = STATE(469), + [aux_sym_cascade_section_repeat1] = STATE(556), + [aux_sym_cascade_section_repeat2] = STATE(485), + [anon_sym_LBRACE] = ACTIONS(1127), + [anon_sym_LBRACK] = ACTIONS(1127), + [anon_sym_COMMA] = ACTIONS(1127), + [anon_sym_LPAREN] = ACTIONS(1127), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1133), + [anon_sym_QMARK] = ACTIONS(1133), + [sym_equality_operator] = ACTIONS(1127), + [anon_sym_LT] = ACTIONS(1133), + [anon_sym_GT] = ACTIONS(1133), + [anon_sym_LT_EQ] = ACTIONS(1127), + [anon_sym_GT_EQ] = ACTIONS(1127), + [anon_sym_PIPE] = ACTIONS(1133), + [anon_sym_CARET] = ACTIONS(1133), + [anon_sym_AMP] = ACTIONS(1133), + [anon_sym_LT_LT] = ACTIONS(1133), + [anon_sym_GT_GT] = ACTIONS(1133), + [anon_sym_GT_GT_GT] = ACTIONS(1133), + [sym__additive_operator] = ACTIONS(1133), + [anon_sym_STAR] = ACTIONS(1133), + [anon_sym_SLASH] = ACTIONS(1133), + [anon_sym_PERCENT] = ACTIONS(1133), + [anon_sym_TILDE_SLASH] = ACTIONS(1133), + [anon_sym_BANG] = ACTIONS(1133), + [anon_sym_is] = ACTIONS(1127), + [anon_sym_as] = ACTIONS(1133), + [anon_sym_DOT] = ACTIONS(1133), + [anon_sym_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT] = ACTIONS(1133), + [anon_sym_SEMI] = ACTIONS(1127), + [anon_sym_EQ_GT] = ACTIONS(1127), + [anon_sym_async] = ACTIONS(1133), + [anon_sym_async_STAR] = ACTIONS(1127), + [anon_sym_sync_STAR] = ACTIONS(1127), + [anon_sym_AMP_AMP] = ACTIONS(1127), + [anon_sym_PIPE_PIPE] = ACTIONS(1127), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(470)] = { + [sym__assignment_operator] = STATE(289), + [sym__cascade_subsection] = STATE(586), + [sym__cascade_assignment_section] = STATE(976), + [sym_index_selector] = STATE(601), + [sym_unconditional_assignable_selector] = STATE(602), + [sym_conditional_assignable_selector] = STATE(602), + [sym__assignable_selector] = STATE(495), + [sym_comment] = STATE(470), + [sym_documentation_comment] = STATE(470), + [aux_sym_cascade_section_repeat2] = STATE(483), + [anon_sym_RBRACE] = ACTIONS(1155), + [anon_sym_LBRACK] = ACTIONS(1155), + [anon_sym_COMMA] = ACTIONS(1155), + [anon_sym_RBRACK] = ACTIONS(1155), + [anon_sym_COLON] = ACTIONS(1155), + [anon_sym_LPAREN] = ACTIONS(1155), + [anon_sym_RPAREN] = ACTIONS(1155), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1157), + [anon_sym_QMARK] = ACTIONS(1157), + [sym_equality_operator] = ACTIONS(1155), + [anon_sym_LT] = ACTIONS(1157), + [anon_sym_GT] = ACTIONS(1157), + [anon_sym_LT_EQ] = ACTIONS(1155), + [anon_sym_GT_EQ] = ACTIONS(1155), + [anon_sym_PIPE] = ACTIONS(1157), + [anon_sym_CARET] = ACTIONS(1157), + [anon_sym_AMP] = ACTIONS(1157), + [anon_sym_LT_LT] = ACTIONS(1157), + [anon_sym_GT_GT] = ACTIONS(1157), + [anon_sym_GT_GT_GT] = ACTIONS(1157), + [sym__additive_operator] = ACTIONS(1157), + [anon_sym_STAR] = ACTIONS(1157), + [anon_sym_SLASH] = ACTIONS(1157), + [anon_sym_PERCENT] = ACTIONS(1157), + [anon_sym_TILDE_SLASH] = ACTIONS(1157), + [anon_sym_BANG] = ACTIONS(1157), + [anon_sym_is] = ACTIONS(1155), + [anon_sym_as] = ACTIONS(1155), + [anon_sym_DOT] = ACTIONS(1157), + [anon_sym_DOT_DOT] = ACTIONS(1155), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1155), + [anon_sym_QMARK_DOT] = ACTIONS(1157), + [anon_sym_SEMI] = ACTIONS(1155), + [anon_sym_EQ_GT] = ACTIONS(1155), + [anon_sym_when] = ACTIONS(1155), + [anon_sym_case] = ACTIONS(1155), + [anon_sym_else] = ACTIONS(1155), + [anon_sym_AMP_AMP] = ACTIONS(1155), + [anon_sym_PIPE_PIPE] = ACTIONS(1155), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(471)] = { + [sym__assignment_operator] = STATE(289), + [sym__cascade_subsection] = STATE(586), + [sym__cascade_assignment_section] = STATE(954), + [sym_index_selector] = STATE(601), + [sym_unconditional_assignable_selector] = STATE(602), + [sym_conditional_assignable_selector] = STATE(602), + [sym__assignable_selector] = STATE(495), + [sym_comment] = STATE(471), + [sym_documentation_comment] = STATE(471), + [aux_sym_cascade_section_repeat2] = STATE(483), + [anon_sym_RBRACE] = ACTIONS(1127), + [anon_sym_LBRACK] = ACTIONS(1127), + [anon_sym_COMMA] = ACTIONS(1127), + [anon_sym_RBRACK] = ACTIONS(1127), + [anon_sym_COLON] = ACTIONS(1127), + [anon_sym_LPAREN] = ACTIONS(1127), + [anon_sym_RPAREN] = ACTIONS(1127), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1133), + [anon_sym_QMARK] = ACTIONS(1133), + [sym_equality_operator] = ACTIONS(1127), + [anon_sym_LT] = ACTIONS(1133), + [anon_sym_GT] = ACTIONS(1133), + [anon_sym_LT_EQ] = ACTIONS(1127), + [anon_sym_GT_EQ] = ACTIONS(1127), + [anon_sym_PIPE] = ACTIONS(1133), + [anon_sym_CARET] = ACTIONS(1133), + [anon_sym_AMP] = ACTIONS(1133), + [anon_sym_LT_LT] = ACTIONS(1133), + [anon_sym_GT_GT] = ACTIONS(1133), + [anon_sym_GT_GT_GT] = ACTIONS(1133), + [sym__additive_operator] = ACTIONS(1133), + [anon_sym_STAR] = ACTIONS(1133), + [anon_sym_SLASH] = ACTIONS(1133), + [anon_sym_PERCENT] = ACTIONS(1133), + [anon_sym_TILDE_SLASH] = ACTIONS(1133), + [anon_sym_BANG] = ACTIONS(1133), + [anon_sym_is] = ACTIONS(1127), + [anon_sym_as] = ACTIONS(1127), + [anon_sym_DOT] = ACTIONS(1133), + [anon_sym_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT] = ACTIONS(1133), + [anon_sym_SEMI] = ACTIONS(1127), + [anon_sym_EQ_GT] = ACTIONS(1127), + [anon_sym_when] = ACTIONS(1127), + [anon_sym_case] = ACTIONS(1127), + [anon_sym_else] = ACTIONS(1127), + [anon_sym_AMP_AMP] = ACTIONS(1127), + [anon_sym_PIPE_PIPE] = ACTIONS(1127), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(472)] = { + [sym__on_part] = STATE(493), + [sym_catch_clause] = STATE(3144), + [sym_comment] = STATE(472), + [sym_documentation_comment] = STATE(472), + [aux_sym_try_statement_repeat1] = STATE(472), + [sym_identifier] = ACTIONS(1159), + [anon_sym_POUND] = ACTIONS(1161), + [sym_decimal_integer_literal] = ACTIONS(1159), + [sym_hex_integer_literal] = ACTIONS(1161), + [sym_decimal_floating_point_literal] = ACTIONS(1159), + [anon_sym_true] = ACTIONS(1159), + [anon_sym_false] = ACTIONS(1159), + [anon_sym_DQUOTE] = ACTIONS(1159), + [anon_sym_SQUOTE] = ACTIONS(1159), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1161), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1161), + [anon_sym_r_DQUOTE] = ACTIONS(1159), + [anon_sym_r_SQUOTE] = ACTIONS(1159), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1161), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1161), + [anon_sym_LBRACE] = ACTIONS(1161), + [anon_sym_RBRACE] = ACTIONS(1161), + [anon_sym_LBRACK] = ACTIONS(1161), + [anon_sym_null] = ACTIONS(1159), + [anon_sym_LPAREN] = ACTIONS(1161), + [anon_sym_throw] = ACTIONS(1159), + [anon_sym_LT] = ACTIONS(1161), + [sym_increment_operator] = ACTIONS(1161), + [sym_minus_operator] = ACTIONS(1159), + [anon_sym_BANG] = ACTIONS(1161), + [anon_sym_TILDE] = ACTIONS(1161), + [anon_sym_await] = ACTIONS(1159), + [anon_sym_switch] = ACTIONS(1159), + [anon_sym_default] = ACTIONS(1159), + [anon_sym_do] = ACTIONS(1159), + [anon_sym_while] = ACTIONS(1159), + [anon_sym_continue] = ACTIONS(1159), + [anon_sym_yield] = ACTIONS(1159), + [anon_sym_return] = ACTIONS(1159), + [anon_sym_on] = ACTIONS(1163), + [anon_sym_try] = ACTIONS(1159), + [anon_sym_catch] = ACTIONS(1166), + [anon_sym_finally] = ACTIONS(1159), + [anon_sym_if] = ACTIONS(1159), + [anon_sym_case] = ACTIONS(1159), + [anon_sym_else] = ACTIONS(1159), + [anon_sym_for] = ACTIONS(1159), + [anon_sym_AT] = ACTIONS(1161), + [anon_sym_final] = ACTIONS(1159), + [sym_void_type] = ACTIONS(1159), + [anon_sym_var] = ACTIONS(1159), + [sym_break_builtin] = ACTIONS(1159), + [sym_assert_builtin] = ACTIONS(1159), + [sym_rethrow_builtin] = ACTIONS(1159), + [anon_sym_covariant] = ACTIONS(1159), + [anon_sym_Function] = ACTIONS(1159), + [anon_sym_get] = ACTIONS(1159), + [anon_sym_set] = ACTIONS(1159), + [anon_sym_new] = ACTIONS(1159), + [sym_const_builtin] = ACTIONS(1159), + [anon_sym_late] = ACTIONS(1159), + [anon_sym_this] = ACTIONS(1159), + [anon_sym_super] = ACTIONS(1159), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(473)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(473), + [sym_documentation_comment] = STATE(473), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1169), + [sym_identifier] = ACTIONS(1171), + [anon_sym_LPAREN] = ACTIONS(1174), + [anon_sym_AT] = ACTIONS(1177), + [anon_sym_enum] = ACTIONS(1180), + [anon_sym_final] = ACTIONS(1183), + [anon_sym_inline] = ACTIONS(1186), + [anon_sym_class] = ACTIONS(1189), + [anon_sym_extension] = ACTIONS(1192), + [sym_void_type] = ACTIONS(1195), + [anon_sym_var] = ACTIONS(1198), + [anon_sym_Function] = ACTIONS(1201), + [anon_sym_get] = ACTIONS(1204), + [anon_sym_interface] = ACTIONS(1207), + [anon_sym_base] = ACTIONS(1210), + [anon_sym_abstract] = ACTIONS(1213), + [anon_sym_sealed] = ACTIONS(1216), + [anon_sym_mixin] = ACTIONS(1219), + [anon_sym_set] = ACTIONS(1222), + [anon_sym_typedef] = ACTIONS(1225), + [sym_const_builtin] = ACTIONS(1228), + [anon_sym_late] = ACTIONS(1231), + [anon_sym_external] = ACTIONS(1234), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(474)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(474), + [sym_documentation_comment] = STATE(474), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1139), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(475)] = { + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_comment] = STATE(475), + [sym_documentation_comment] = STATE(475), + [aux_sym_string_literal_repeat1] = STATE(475), + [anon_sym_DQUOTE] = ACTIONS(1237), + [anon_sym_SQUOTE] = ACTIONS(1240), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1243), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1246), + [anon_sym_r_DQUOTE] = ACTIONS(1249), + [anon_sym_r_SQUOTE] = ACTIONS(1252), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1255), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1258), + [anon_sym_RBRACE] = ACTIONS(1261), + [anon_sym_LBRACK] = ACTIONS(1261), + [anon_sym_COMMA] = ACTIONS(1261), + [anon_sym_RBRACK] = ACTIONS(1261), + [anon_sym_COLON] = ACTIONS(1261), + [anon_sym_LPAREN] = ACTIONS(1261), + [anon_sym_RPAREN] = ACTIONS(1261), + [anon_sym_QMARK_QMARK] = ACTIONS(1261), + [anon_sym_QMARK] = ACTIONS(1263), + [sym_equality_operator] = ACTIONS(1261), + [anon_sym_LT] = ACTIONS(1263), + [anon_sym_GT] = ACTIONS(1263), + [anon_sym_LT_EQ] = ACTIONS(1261), + [anon_sym_GT_EQ] = ACTIONS(1261), + [anon_sym_PIPE] = ACTIONS(1263), + [anon_sym_CARET] = ACTIONS(1261), + [anon_sym_AMP] = ACTIONS(1263), + [anon_sym_LT_LT] = ACTIONS(1261), + [anon_sym_GT_GT] = ACTIONS(1263), + [anon_sym_GT_GT_GT] = ACTIONS(1261), + [sym__additive_operator] = ACTIONS(1261), + [anon_sym_STAR] = ACTIONS(1261), + [anon_sym_SLASH] = ACTIONS(1263), + [anon_sym_PERCENT] = ACTIONS(1261), + [anon_sym_TILDE_SLASH] = ACTIONS(1261), + [anon_sym_BANG] = ACTIONS(1263), + [anon_sym_is] = ACTIONS(1261), + [anon_sym_as] = ACTIONS(1261), + [anon_sym_DOT] = ACTIONS(1263), + [anon_sym_DOT_DOT] = ACTIONS(1261), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1261), + [anon_sym_QMARK_DOT] = ACTIONS(1263), + [anon_sym_SEMI] = ACTIONS(1261), + [anon_sym_EQ_GT] = ACTIONS(1261), + [anon_sym_when] = ACTIONS(1261), + [anon_sym_if] = ACTIONS(1261), + [anon_sym_case] = ACTIONS(1261), + [anon_sym_else] = ACTIONS(1261), + [anon_sym_show] = ACTIONS(1261), + [anon_sym_hide] = ACTIONS(1261), + [anon_sym_deferred] = ACTIONS(1261), + [anon_sym_AMP_AMP] = ACTIONS(1261), + [anon_sym_PIPE_PIPE] = ACTIONS(1261), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(476)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(476), + [sym_documentation_comment] = STATE(476), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1049), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(477)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(477), + [sym_documentation_comment] = STATE(477), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1125), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(478)] = { + [sym__string_literal_double_quotes] = STATE(622), + [sym__string_literal_single_quotes] = STATE(622), + [sym__string_literal_double_quotes_multiple] = STATE(622), + [sym__string_literal_single_quotes_multiple] = STATE(622), + [sym__raw_string_literal_double_quotes] = STATE(622), + [sym__raw_string_literal_single_quotes] = STATE(622), + [sym__raw_string_literal_double_quotes_multiple] = STATE(622), + [sym__raw_string_literal_single_quotes_multiple] = STATE(622), + [sym_comment] = STATE(478), + [sym_documentation_comment] = STATE(478), + [aux_sym_string_literal_repeat1] = STATE(475), + [anon_sym_DQUOTE] = ACTIONS(83), + [anon_sym_SQUOTE] = ACTIONS(85), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(87), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(89), + [anon_sym_r_DQUOTE] = ACTIONS(91), + [anon_sym_r_SQUOTE] = ACTIONS(93), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(95), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(97), + [anon_sym_RBRACE] = ACTIONS(1265), + [anon_sym_LBRACK] = ACTIONS(1265), + [anon_sym_COMMA] = ACTIONS(1265), + [anon_sym_RBRACK] = ACTIONS(1265), + [anon_sym_COLON] = ACTIONS(1265), + [anon_sym_LPAREN] = ACTIONS(1265), + [anon_sym_RPAREN] = ACTIONS(1265), + [anon_sym_QMARK_QMARK] = ACTIONS(1265), + [anon_sym_QMARK] = ACTIONS(1267), + [sym_equality_operator] = ACTIONS(1265), + [anon_sym_LT] = ACTIONS(1267), + [anon_sym_GT] = ACTIONS(1267), + [anon_sym_LT_EQ] = ACTIONS(1265), + [anon_sym_GT_EQ] = ACTIONS(1265), + [anon_sym_PIPE] = ACTIONS(1267), + [anon_sym_CARET] = ACTIONS(1265), + [anon_sym_AMP] = ACTIONS(1267), + [anon_sym_LT_LT] = ACTIONS(1265), + [anon_sym_GT_GT] = ACTIONS(1267), + [anon_sym_GT_GT_GT] = ACTIONS(1265), + [sym__additive_operator] = ACTIONS(1265), + [anon_sym_STAR] = ACTIONS(1265), + [anon_sym_SLASH] = ACTIONS(1267), + [anon_sym_PERCENT] = ACTIONS(1265), + [anon_sym_TILDE_SLASH] = ACTIONS(1265), + [anon_sym_BANG] = ACTIONS(1267), + [anon_sym_is] = ACTIONS(1265), + [anon_sym_as] = ACTIONS(1265), + [anon_sym_DOT] = ACTIONS(1267), + [anon_sym_DOT_DOT] = ACTIONS(1265), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1265), + [anon_sym_QMARK_DOT] = ACTIONS(1267), + [anon_sym_SEMI] = ACTIONS(1265), + [anon_sym_EQ_GT] = ACTIONS(1265), + [anon_sym_when] = ACTIONS(1265), + [anon_sym_if] = ACTIONS(1265), + [anon_sym_case] = ACTIONS(1265), + [anon_sym_else] = ACTIONS(1265), + [anon_sym_show] = ACTIONS(1265), + [anon_sym_hide] = ACTIONS(1265), + [anon_sym_deferred] = ACTIONS(1265), + [anon_sym_AMP_AMP] = ACTIONS(1265), + [anon_sym_PIPE_PIPE] = ACTIONS(1265), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(479)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(479), + [sym_documentation_comment] = STATE(479), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1269), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(480)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(480), + [sym_documentation_comment] = STATE(480), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1045), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(481)] = { + [sym__top_level_definition] = STATE(1772), + [sym_annotation] = STATE(1415), + [sym_enum_declaration] = STATE(1803), + [sym_type_alias] = STATE(1803), + [sym__class_modifiers] = STATE(3178), + [sym__mixin_class_modifiers] = STATE(3435), + [sym_class_definition] = STATE(1803), + [sym_extension_declaration] = STATE(1803), + [sym_extension_type_declaration] = STATE(1803), + [sym__metadata] = STATE(684), + [sym_mixin_declaration] = STATE(1803), + [sym_getter_signature] = STATE(2222), + [sym_setter_signature] = STATE(2222), + [sym__type] = STATE(2424), + [sym__type_not_function] = STATE(1816), + [sym__type_not_void_not_function] = STATE(1920), + [sym_function_type] = STATE(1853), + [aux_sym__function_type_tails] = STATE(1605), + [sym__function_type_tail] = STATE(1702), + [sym_record_type] = STATE(1830), + [sym__type_name] = STATE(1530), + [sym_inferred_type] = STATE(2813), + [sym_function_signature] = STATE(2222), + [sym__function_builtin_identifier] = STATE(1502), + [sym__get] = STATE(2407), + [sym_interface] = STATE(3392), + [sym_base] = STATE(2937), + [sym_abstract] = STATE(2281), + [sym_sealed] = STATE(3392), + [sym_mixin] = STATE(3206), + [sym__set] = STATE(2449), + [sym__typedef] = STATE(2121), + [sym_final_builtin] = STATE(2024), + [sym__late_builtin] = STATE(1976), + [sym__external_builtin] = STATE(1873), + [sym_comment] = STATE(481), + [sym_documentation_comment] = STATE(481), + [aux_sym_program_repeat4] = STATE(473), + [aux_sym__metadata_repeat1] = STATE(1329), + [ts_builtin_sym_end] = ACTIONS(1047), + [sym_identifier] = ACTIONS(15), + [anon_sym_LPAREN] = ACTIONS(17), + [anon_sym_AT] = ACTIONS(143), + [anon_sym_enum] = ACTIONS(23), + [anon_sym_final] = ACTIONS(25), + [anon_sym_inline] = ACTIONS(27), + [anon_sym_class] = ACTIONS(29), + [anon_sym_extension] = ACTIONS(31), + [sym_void_type] = ACTIONS(33), + [anon_sym_var] = ACTIONS(35), + [anon_sym_Function] = ACTIONS(45), + [anon_sym_get] = ACTIONS(47), + [anon_sym_interface] = ACTIONS(51), + [anon_sym_base] = ACTIONS(53), + [anon_sym_abstract] = ACTIONS(55), + [anon_sym_sealed] = ACTIONS(57), + [anon_sym_mixin] = ACTIONS(59), + [anon_sym_set] = ACTIONS(61), + [anon_sym_typedef] = ACTIONS(63), + [sym_const_builtin] = ACTIONS(65), + [anon_sym_late] = ACTIONS(67), + [anon_sym_external] = ACTIONS(69), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(482)] = { + [aux_sym__if_null_expression] = STATE(840), + [sym_relational_operator] = STATE(333), + [sym_shift_operator] = STATE(334), + [sym__shift_operator] = STATE(1346), + [sym_additive_operator] = STATE(335), + [sym_type_test] = STATE(916), + [sym_is_operator] = STATE(2087), + [sym_type_cast] = STATE(917), + [sym_as_operator] = STATE(2088), + [sym_cascade_section] = STATE(939), + [sym_logical_and_operator] = STATE(336), + [sym_logical_or_operator] = STATE(337), + [sym_comment] = STATE(482), + [sym_documentation_comment] = STATE(482), + [aux_sym__expression_repeat1] = STATE(828), + [aux_sym_logical_or_expression_repeat1] = STATE(834), + [aux_sym_logical_and_expression_repeat1] = STATE(835), + [aux_sym_bitwise_or_expression_repeat1] = STATE(841), + [aux_sym_bitwise_xor_expression_repeat1] = STATE(842), + [aux_sym_bitwise_and_expression_repeat1] = STATE(843), + [aux_sym_shift_expression_repeat1] = STATE(801), + [aux_sym_additive_expression_repeat1] = STATE(817), + [anon_sym_RBRACE] = ACTIONS(1271), + [anon_sym_LBRACK] = ACTIONS(1271), + [anon_sym_COMMA] = ACTIONS(1271), + [anon_sym_RBRACK] = ACTIONS(1271), + [anon_sym_COLON] = ACTIONS(1271), + [anon_sym_LPAREN] = ACTIONS(1271), + [anon_sym_RPAREN] = ACTIONS(1271), + [anon_sym_QMARK_QMARK] = ACTIONS(1273), + [anon_sym_QMARK] = ACTIONS(1275), + [sym_equality_operator] = ACTIONS(1277), + [anon_sym_LT] = ACTIONS(368), + [anon_sym_GT] = ACTIONS(368), + [anon_sym_LT_EQ] = ACTIONS(370), + [anon_sym_GT_EQ] = ACTIONS(370), + [anon_sym_PIPE] = ACTIONS(1279), + [anon_sym_CARET] = ACTIONS(1281), + [anon_sym_AMP] = ACTIONS(1283), + [anon_sym_LT_LT] = ACTIONS(1285), + [anon_sym_GT_GT] = ACTIONS(1287), + [anon_sym_GT_GT_GT] = ACTIONS(1285), + [sym__additive_operator] = ACTIONS(1289), + [anon_sym_STAR] = ACTIONS(1271), + [anon_sym_SLASH] = ACTIONS(1291), + [anon_sym_PERCENT] = ACTIONS(1271), + [anon_sym_TILDE_SLASH] = ACTIONS(1271), + [anon_sym_BANG] = ACTIONS(1291), + [anon_sym_is] = ACTIONS(1293), + [anon_sym_as] = ACTIONS(1295), + [anon_sym_DOT] = ACTIONS(1291), + [anon_sym_DOT_DOT] = ACTIONS(1297), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1297), + [anon_sym_QMARK_DOT] = ACTIONS(1291), + [anon_sym_SEMI] = ACTIONS(1271), + [anon_sym_EQ_GT] = ACTIONS(1271), + [anon_sym_when] = ACTIONS(1271), + [anon_sym_case] = ACTIONS(1271), + [anon_sym_else] = ACTIONS(1271), + [anon_sym_AMP_AMP] = ACTIONS(1300), + [anon_sym_PIPE_PIPE] = ACTIONS(1302), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(483)] = { + [sym__cascade_subsection] = STATE(586), + [sym_index_selector] = STATE(601), + [sym_unconditional_assignable_selector] = STATE(602), + [sym_conditional_assignable_selector] = STATE(602), + [sym__assignable_selector] = STATE(495), + [sym_comment] = STATE(483), + [sym_documentation_comment] = STATE(483), + [aux_sym_cascade_section_repeat2] = STATE(483), + [anon_sym_RBRACE] = ACTIONS(1304), + [anon_sym_LBRACK] = ACTIONS(1306), + [anon_sym_COMMA] = ACTIONS(1304), + [anon_sym_RBRACK] = ACTIONS(1304), + [anon_sym_COLON] = ACTIONS(1304), + [anon_sym_LPAREN] = ACTIONS(1304), + [anon_sym_RPAREN] = ACTIONS(1304), + [anon_sym_EQ] = ACTIONS(1309), + [anon_sym_PLUS_EQ] = ACTIONS(1304), + [anon_sym_DASH_EQ] = ACTIONS(1304), + [anon_sym_STAR_EQ] = ACTIONS(1304), + [anon_sym_SLASH_EQ] = ACTIONS(1304), + [anon_sym_PERCENT_EQ] = ACTIONS(1304), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1304), + [anon_sym_LT_LT_EQ] = ACTIONS(1304), + [anon_sym_GT_GT_EQ] = ACTIONS(1304), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1304), + [anon_sym_AMP_EQ] = ACTIONS(1304), + [anon_sym_CARET_EQ] = ACTIONS(1304), + [anon_sym_PIPE_EQ] = ACTIONS(1304), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1304), + [anon_sym_QMARK_QMARK] = ACTIONS(1309), + [anon_sym_QMARK] = ACTIONS(1311), + [sym_equality_operator] = ACTIONS(1304), + [anon_sym_LT] = ACTIONS(1309), + [anon_sym_GT] = ACTIONS(1309), + [anon_sym_LT_EQ] = ACTIONS(1304), + [anon_sym_GT_EQ] = ACTIONS(1304), + [anon_sym_PIPE] = ACTIONS(1309), + [anon_sym_CARET] = ACTIONS(1309), + [anon_sym_AMP] = ACTIONS(1309), + [anon_sym_LT_LT] = ACTIONS(1309), + [anon_sym_GT_GT] = ACTIONS(1309), + [anon_sym_GT_GT_GT] = ACTIONS(1309), + [sym__additive_operator] = ACTIONS(1309), + [anon_sym_STAR] = ACTIONS(1309), + [anon_sym_SLASH] = ACTIONS(1309), + [anon_sym_PERCENT] = ACTIONS(1309), + [anon_sym_TILDE_SLASH] = ACTIONS(1309), + [anon_sym_BANG] = ACTIONS(1309), + [anon_sym_is] = ACTIONS(1304), + [anon_sym_as] = ACTIONS(1304), + [anon_sym_DOT] = ACTIONS(1314), + [anon_sym_DOT_DOT] = ACTIONS(1304), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1304), + [anon_sym_QMARK_DOT] = ACTIONS(1317), + [anon_sym_SEMI] = ACTIONS(1304), + [anon_sym_EQ_GT] = ACTIONS(1304), + [anon_sym_when] = ACTIONS(1304), + [anon_sym_case] = ACTIONS(1304), + [anon_sym_else] = ACTIONS(1304), + [anon_sym_AMP_AMP] = ACTIONS(1304), + [anon_sym_PIPE_PIPE] = ACTIONS(1304), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(484)] = { + [sym_type_parameters] = STATE(2898), + [sym__type_dot_identifier] = STATE(1607), + [sym__formal_parameter_part] = STATE(2300), + [sym_formal_parameter_list] = STATE(2070), + [sym__strict_formal_parameter_list] = STATE(2071), + [sym_comment] = STATE(484), + [sym_documentation_comment] = STATE(484), + [sym_identifier] = ACTIONS(1320), + [anon_sym_RBRACE] = ACTIONS(1322), + [anon_sym_LBRACK] = ACTIONS(1322), + [anon_sym_COMMA] = ACTIONS(1322), + [anon_sym_COLON] = ACTIONS(1322), + [anon_sym_LPAREN] = ACTIONS(1324), + [anon_sym_EQ] = ACTIONS(1328), + [anon_sym_PLUS_EQ] = ACTIONS(1330), + [anon_sym_DASH_EQ] = ACTIONS(1330), + [anon_sym_STAR_EQ] = ACTIONS(1330), + [anon_sym_SLASH_EQ] = ACTIONS(1330), + [anon_sym_PERCENT_EQ] = ACTIONS(1330), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1330), + [anon_sym_LT_LT_EQ] = ACTIONS(1330), + [anon_sym_GT_GT_EQ] = ACTIONS(1330), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1330), + [anon_sym_AMP_EQ] = ACTIONS(1330), + [anon_sym_CARET_EQ] = ACTIONS(1330), + [anon_sym_PIPE_EQ] = ACTIONS(1330), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1330), + [anon_sym_QMARK_QMARK] = ACTIONS(1332), + [anon_sym_QMARK] = ACTIONS(1334), + [sym_equality_operator] = ACTIONS(1322), + [anon_sym_LT] = ACTIONS(1337), + [anon_sym_GT] = ACTIONS(1332), + [anon_sym_LT_EQ] = ACTIONS(1322), + [anon_sym_GT_EQ] = ACTIONS(1322), + [anon_sym_PIPE] = ACTIONS(1332), + [anon_sym_CARET] = ACTIONS(1332), + [anon_sym_AMP] = ACTIONS(1332), + [anon_sym_LT_LT] = ACTIONS(1332), + [anon_sym_GT_GT] = ACTIONS(1332), + [anon_sym_GT_GT_GT] = ACTIONS(1332), + [sym__additive_operator] = ACTIONS(1332), + [anon_sym_STAR] = ACTIONS(1332), + [anon_sym_SLASH] = ACTIONS(1332), + [anon_sym_PERCENT] = ACTIONS(1332), + [anon_sym_TILDE_SLASH] = ACTIONS(1332), + [sym_increment_operator] = ACTIONS(1330), + [anon_sym_BANG] = ACTIONS(1332), + [anon_sym_is] = ACTIONS(1332), + [anon_sym_as] = ACTIONS(1332), + [anon_sym_DOT] = ACTIONS(1341), + [anon_sym_DOT_DOT] = ACTIONS(1322), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1322), + [anon_sym_QMARK_DOT] = ACTIONS(1332), + [anon_sym_SEMI] = ACTIONS(1322), + [anon_sym_else] = ACTIONS(1332), + [anon_sym_Function] = ACTIONS(1320), + [anon_sym_get] = ACTIONS(1320), + [anon_sym_set] = ACTIONS(1320), + [anon_sym_AMP_AMP] = ACTIONS(1322), + [anon_sym_PIPE_PIPE] = ACTIONS(1322), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(485)] = { + [sym__assignment_operator] = STATE(288), + [sym__cascade_subsection] = STATE(644), + [sym__cascade_assignment_section] = STATE(1120), + [sym_index_selector] = STATE(640), + [sym_unconditional_assignable_selector] = STATE(641), + [sym_conditional_assignable_selector] = STATE(641), + [sym__assignable_selector] = STATE(560), + [sym_comment] = STATE(485), + [sym_documentation_comment] = STATE(485), + [aux_sym_cascade_section_repeat2] = STATE(510), + [anon_sym_LBRACE] = ACTIONS(1155), + [anon_sym_LBRACK] = ACTIONS(1155), + [anon_sym_COMMA] = ACTIONS(1155), + [anon_sym_LPAREN] = ACTIONS(1155), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1157), + [anon_sym_QMARK] = ACTIONS(1157), + [sym_equality_operator] = ACTIONS(1155), + [anon_sym_LT] = ACTIONS(1157), + [anon_sym_GT] = ACTIONS(1157), + [anon_sym_LT_EQ] = ACTIONS(1155), + [anon_sym_GT_EQ] = ACTIONS(1155), + [anon_sym_PIPE] = ACTIONS(1157), + [anon_sym_CARET] = ACTIONS(1157), + [anon_sym_AMP] = ACTIONS(1157), + [anon_sym_LT_LT] = ACTIONS(1157), + [anon_sym_GT_GT] = ACTIONS(1157), + [anon_sym_GT_GT_GT] = ACTIONS(1157), + [sym__additive_operator] = ACTIONS(1157), + [anon_sym_STAR] = ACTIONS(1157), + [anon_sym_SLASH] = ACTIONS(1157), + [anon_sym_PERCENT] = ACTIONS(1157), + [anon_sym_TILDE_SLASH] = ACTIONS(1157), + [anon_sym_BANG] = ACTIONS(1157), + [anon_sym_is] = ACTIONS(1155), + [anon_sym_as] = ACTIONS(1157), + [anon_sym_DOT] = ACTIONS(1157), + [anon_sym_DOT_DOT] = ACTIONS(1155), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1155), + [anon_sym_QMARK_DOT] = ACTIONS(1157), + [anon_sym_SEMI] = ACTIONS(1155), + [anon_sym_EQ_GT] = ACTIONS(1155), + [anon_sym_async] = ACTIONS(1157), + [anon_sym_async_STAR] = ACTIONS(1155), + [anon_sym_sync_STAR] = ACTIONS(1155), + [anon_sym_AMP_AMP] = ACTIONS(1155), + [anon_sym_PIPE_PIPE] = ACTIONS(1155), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(486)] = { + [sym_comment] = STATE(486), + [sym_documentation_comment] = STATE(486), + [sym_identifier] = ACTIONS(1345), + [anon_sym_POUND] = ACTIONS(1347), + [sym_decimal_integer_literal] = ACTIONS(1345), + [sym_hex_integer_literal] = ACTIONS(1347), + [sym_decimal_floating_point_literal] = ACTIONS(1345), + [anon_sym_true] = ACTIONS(1345), + [anon_sym_false] = ACTIONS(1345), + [anon_sym_DQUOTE] = ACTIONS(1345), + [anon_sym_SQUOTE] = ACTIONS(1345), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1347), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1347), + [anon_sym_r_DQUOTE] = ACTIONS(1345), + [anon_sym_r_SQUOTE] = ACTIONS(1345), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1347), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1347), + [anon_sym_LBRACE] = ACTIONS(1347), + [anon_sym_RBRACE] = ACTIONS(1347), + [anon_sym_LBRACK] = ACTIONS(1347), + [anon_sym_null] = ACTIONS(1345), + [anon_sym_LPAREN] = ACTIONS(1347), + [anon_sym_throw] = ACTIONS(1345), + [anon_sym_LT] = ACTIONS(1347), + [sym_increment_operator] = ACTIONS(1347), + [sym_minus_operator] = ACTIONS(1345), + [anon_sym_BANG] = ACTIONS(1347), + [anon_sym_TILDE] = ACTIONS(1347), + [anon_sym_await] = ACTIONS(1345), + [anon_sym_switch] = ACTIONS(1345), + [anon_sym_default] = ACTIONS(1345), + [anon_sym_do] = ACTIONS(1345), + [anon_sym_while] = ACTIONS(1345), + [anon_sym_continue] = ACTIONS(1345), + [anon_sym_yield] = ACTIONS(1345), + [anon_sym_return] = ACTIONS(1345), + [anon_sym_on] = ACTIONS(1345), + [anon_sym_try] = ACTIONS(1345), + [anon_sym_catch] = ACTIONS(1345), + [anon_sym_finally] = ACTIONS(1345), + [anon_sym_if] = ACTIONS(1345), + [anon_sym_case] = ACTIONS(1345), + [anon_sym_else] = ACTIONS(1345), + [anon_sym_for] = ACTIONS(1345), + [anon_sym_AT] = ACTIONS(1347), + [anon_sym_final] = ACTIONS(1345), + [sym_void_type] = ACTIONS(1345), + [anon_sym_var] = ACTIONS(1345), + [sym_break_builtin] = ACTIONS(1345), + [sym_assert_builtin] = ACTIONS(1345), + [sym_rethrow_builtin] = ACTIONS(1345), + [anon_sym_covariant] = ACTIONS(1345), + [anon_sym_Function] = ACTIONS(1345), + [anon_sym_get] = ACTIONS(1345), + [anon_sym_set] = ACTIONS(1345), + [anon_sym_new] = ACTIONS(1345), + [sym_const_builtin] = ACTIONS(1345), + [anon_sym_late] = ACTIONS(1345), + [anon_sym_this] = ACTIONS(1345), + [anon_sym_super] = ACTIONS(1345), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(487)] = { + [sym__assignment_operator] = STATE(288), + [sym__cascade_subsection] = STATE(644), + [sym__cascade_assignment_section] = STATE(1116), + [sym_index_selector] = STATE(640), + [sym_unconditional_assignable_selector] = STATE(641), + [sym_conditional_assignable_selector] = STATE(641), + [sym__assignable_selector] = STATE(560), + [sym_comment] = STATE(487), + [sym_documentation_comment] = STATE(487), + [aux_sym_cascade_section_repeat2] = STATE(510), + [anon_sym_LBRACE] = ACTIONS(1127), + [anon_sym_LBRACK] = ACTIONS(1127), + [anon_sym_COMMA] = ACTIONS(1127), + [anon_sym_LPAREN] = ACTIONS(1127), + [anon_sym_EQ] = ACTIONS(1129), + [anon_sym_PLUS_EQ] = ACTIONS(1131), + [anon_sym_DASH_EQ] = ACTIONS(1131), + [anon_sym_STAR_EQ] = ACTIONS(1131), + [anon_sym_SLASH_EQ] = ACTIONS(1131), + [anon_sym_PERCENT_EQ] = ACTIONS(1131), + [anon_sym_TILDE_SLASH_EQ] = ACTIONS(1131), + [anon_sym_LT_LT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_GT_GT_GT_EQ] = ACTIONS(1131), + [anon_sym_AMP_EQ] = ACTIONS(1131), + [anon_sym_CARET_EQ] = ACTIONS(1131), + [anon_sym_PIPE_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK_EQ] = ACTIONS(1131), + [anon_sym_QMARK_QMARK] = ACTIONS(1133), + [anon_sym_QMARK] = ACTIONS(1133), + [sym_equality_operator] = ACTIONS(1127), + [anon_sym_LT] = ACTIONS(1133), + [anon_sym_GT] = ACTIONS(1133), + [anon_sym_LT_EQ] = ACTIONS(1127), + [anon_sym_GT_EQ] = ACTIONS(1127), + [anon_sym_PIPE] = ACTIONS(1133), + [anon_sym_CARET] = ACTIONS(1133), + [anon_sym_AMP] = ACTIONS(1133), + [anon_sym_LT_LT] = ACTIONS(1133), + [anon_sym_GT_GT] = ACTIONS(1133), + [anon_sym_GT_GT_GT] = ACTIONS(1133), + [sym__additive_operator] = ACTIONS(1133), + [anon_sym_STAR] = ACTIONS(1133), + [anon_sym_SLASH] = ACTIONS(1133), + [anon_sym_PERCENT] = ACTIONS(1133), + [anon_sym_TILDE_SLASH] = ACTIONS(1133), + [anon_sym_BANG] = ACTIONS(1133), + [anon_sym_is] = ACTIONS(1127), + [anon_sym_as] = ACTIONS(1133), + [anon_sym_DOT] = ACTIONS(1133), + [anon_sym_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT_DOT] = ACTIONS(1127), + [anon_sym_QMARK_DOT] = ACTIONS(1133), + [anon_sym_SEMI] = ACTIONS(1127), + [anon_sym_EQ_GT] = ACTIONS(1127), + [anon_sym_async] = ACTIONS(1133), + [anon_sym_async_STAR] = ACTIONS(1127), + [anon_sym_sync_STAR] = ACTIONS(1127), + [anon_sym_AMP_AMP] = ACTIONS(1127), + [anon_sym_PIPE_PIPE] = ACTIONS(1127), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(488)] = { + [sym_comment] = STATE(488), + [sym_documentation_comment] = STATE(488), + [sym_identifier] = ACTIONS(1053), + [anon_sym_POUND] = ACTIONS(1051), + [sym_decimal_integer_literal] = ACTIONS(1053), + [sym_hex_integer_literal] = ACTIONS(1051), + [sym_decimal_floating_point_literal] = ACTIONS(1053), + [anon_sym_true] = ACTIONS(1053), + [anon_sym_false] = ACTIONS(1053), + [anon_sym_DQUOTE] = ACTIONS(1053), + [anon_sym_SQUOTE] = ACTIONS(1053), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1051), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1051), + [anon_sym_r_DQUOTE] = ACTIONS(1053), + [anon_sym_r_SQUOTE] = ACTIONS(1053), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1051), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1051), + [anon_sym_LBRACE] = ACTIONS(1051), + [anon_sym_RBRACE] = ACTIONS(1051), + [anon_sym_LBRACK] = ACTIONS(1051), + [anon_sym_null] = ACTIONS(1053), + [anon_sym_LPAREN] = ACTIONS(1051), + [anon_sym_throw] = ACTIONS(1053), + [anon_sym_LT] = ACTIONS(1051), + [sym_increment_operator] = ACTIONS(1051), + [sym_minus_operator] = ACTIONS(1053), + [anon_sym_BANG] = ACTIONS(1051), + [anon_sym_TILDE] = ACTIONS(1051), + [anon_sym_await] = ACTIONS(1053), + [anon_sym_switch] = ACTIONS(1053), + [anon_sym_default] = ACTIONS(1053), + [anon_sym_do] = ACTIONS(1053), + [anon_sym_while] = ACTIONS(1053), + [anon_sym_continue] = ACTIONS(1053), + [anon_sym_yield] = ACTIONS(1053), + [anon_sym_return] = ACTIONS(1053), + [anon_sym_on] = ACTIONS(1053), + [anon_sym_try] = ACTIONS(1053), + [anon_sym_catch] = ACTIONS(1053), + [anon_sym_finally] = ACTIONS(1053), + [anon_sym_if] = ACTIONS(1053), + [anon_sym_case] = ACTIONS(1053), + [anon_sym_else] = ACTIONS(1053), + [anon_sym_for] = ACTIONS(1053), + [anon_sym_AT] = ACTIONS(1051), + [anon_sym_final] = ACTIONS(1053), + [sym_void_type] = ACTIONS(1053), + [anon_sym_var] = ACTIONS(1053), + [sym_break_builtin] = ACTIONS(1053), + [sym_assert_builtin] = ACTIONS(1053), + [sym_rethrow_builtin] = ACTIONS(1053), + [anon_sym_covariant] = ACTIONS(1053), + [anon_sym_Function] = ACTIONS(1053), + [anon_sym_get] = ACTIONS(1053), + [anon_sym_set] = ACTIONS(1053), + [anon_sym_new] = ACTIONS(1053), + [sym_const_builtin] = ACTIONS(1053), + [anon_sym_late] = ACTIONS(1053), + [anon_sym_this] = ACTIONS(1053), + [anon_sym_super] = ACTIONS(1053), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(489)] = { + [sym_comment] = STATE(489), + [sym_documentation_comment] = STATE(489), + [sym_identifier] = ACTIONS(1349), + [anon_sym_POUND] = ACTIONS(1351), + [sym_decimal_integer_literal] = ACTIONS(1349), + [sym_hex_integer_literal] = ACTIONS(1351), + [sym_decimal_floating_point_literal] = ACTIONS(1349), + [anon_sym_true] = ACTIONS(1349), + [anon_sym_false] = ACTIONS(1349), + [anon_sym_DQUOTE] = ACTIONS(1349), + [anon_sym_SQUOTE] = ACTIONS(1349), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1351), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1351), + [anon_sym_r_DQUOTE] = ACTIONS(1349), + [anon_sym_r_SQUOTE] = ACTIONS(1349), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1351), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1351), + [anon_sym_LBRACE] = ACTIONS(1351), + [anon_sym_RBRACE] = ACTIONS(1351), + [anon_sym_LBRACK] = ACTIONS(1351), + [anon_sym_null] = ACTIONS(1349), + [anon_sym_LPAREN] = ACTIONS(1351), + [anon_sym_throw] = ACTIONS(1349), + [anon_sym_LT] = ACTIONS(1351), + [sym_increment_operator] = ACTIONS(1351), + [sym_minus_operator] = ACTIONS(1349), + [anon_sym_BANG] = ACTIONS(1351), + [anon_sym_TILDE] = ACTIONS(1351), + [anon_sym_await] = ACTIONS(1349), + [anon_sym_switch] = ACTIONS(1349), + [anon_sym_default] = ACTIONS(1349), + [anon_sym_do] = ACTIONS(1349), + [anon_sym_while] = ACTIONS(1349), + [anon_sym_continue] = ACTIONS(1349), + [anon_sym_yield] = ACTIONS(1349), + [anon_sym_return] = ACTIONS(1349), + [anon_sym_on] = ACTIONS(1349), + [anon_sym_try] = ACTIONS(1349), + [anon_sym_catch] = ACTIONS(1349), + [anon_sym_finally] = ACTIONS(1349), + [anon_sym_if] = ACTIONS(1349), + [anon_sym_case] = ACTIONS(1349), + [anon_sym_else] = ACTIONS(1349), + [anon_sym_for] = ACTIONS(1349), + [anon_sym_AT] = ACTIONS(1351), + [anon_sym_final] = ACTIONS(1349), + [sym_void_type] = ACTIONS(1349), + [anon_sym_var] = ACTIONS(1349), + [sym_break_builtin] = ACTIONS(1349), + [sym_assert_builtin] = ACTIONS(1349), + [sym_rethrow_builtin] = ACTIONS(1349), + [anon_sym_covariant] = ACTIONS(1349), + [anon_sym_Function] = ACTIONS(1349), + [anon_sym_get] = ACTIONS(1349), + [anon_sym_set] = ACTIONS(1349), + [anon_sym_new] = ACTIONS(1349), + [sym_const_builtin] = ACTIONS(1349), + [anon_sym_late] = ACTIONS(1349), + [anon_sym_this] = ACTIONS(1349), + [anon_sym_super] = ACTIONS(1349), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(490)] = { + [sym_comment] = STATE(490), + [sym_documentation_comment] = STATE(490), + [sym_identifier] = ACTIONS(1353), + [anon_sym_POUND] = ACTIONS(1355), + [sym_decimal_integer_literal] = ACTIONS(1353), + [sym_hex_integer_literal] = ACTIONS(1355), + [sym_decimal_floating_point_literal] = ACTIONS(1353), + [anon_sym_true] = ACTIONS(1353), + [anon_sym_false] = ACTIONS(1353), + [anon_sym_DQUOTE] = ACTIONS(1353), + [anon_sym_SQUOTE] = ACTIONS(1353), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1355), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1355), + [anon_sym_r_DQUOTE] = ACTIONS(1353), + [anon_sym_r_SQUOTE] = ACTIONS(1353), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1355), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1355), + [anon_sym_LBRACE] = ACTIONS(1355), + [anon_sym_RBRACE] = ACTIONS(1355), + [anon_sym_LBRACK] = ACTIONS(1355), + [anon_sym_null] = ACTIONS(1353), + [anon_sym_LPAREN] = ACTIONS(1355), + [anon_sym_throw] = ACTIONS(1353), + [anon_sym_LT] = ACTIONS(1355), + [sym_increment_operator] = ACTIONS(1355), + [sym_minus_operator] = ACTIONS(1353), + [anon_sym_BANG] = ACTIONS(1355), + [anon_sym_TILDE] = ACTIONS(1355), + [anon_sym_await] = ACTIONS(1353), + [anon_sym_switch] = ACTIONS(1353), + [anon_sym_default] = ACTIONS(1353), + [anon_sym_do] = ACTIONS(1353), + [anon_sym_while] = ACTIONS(1353), + [anon_sym_continue] = ACTIONS(1353), + [anon_sym_yield] = ACTIONS(1353), + [anon_sym_return] = ACTIONS(1353), + [anon_sym_on] = ACTIONS(1353), + [anon_sym_try] = ACTIONS(1353), + [anon_sym_catch] = ACTIONS(1353), + [anon_sym_finally] = ACTIONS(1353), + [anon_sym_if] = ACTIONS(1353), + [anon_sym_case] = ACTIONS(1353), + [anon_sym_else] = ACTIONS(1353), + [anon_sym_for] = ACTIONS(1353), + [anon_sym_AT] = ACTIONS(1355), + [anon_sym_final] = ACTIONS(1353), + [sym_void_type] = ACTIONS(1353), + [anon_sym_var] = ACTIONS(1353), + [sym_break_builtin] = ACTIONS(1353), + [sym_assert_builtin] = ACTIONS(1353), + [sym_rethrow_builtin] = ACTIONS(1353), + [anon_sym_covariant] = ACTIONS(1353), + [anon_sym_Function] = ACTIONS(1353), + [anon_sym_get] = ACTIONS(1353), + [anon_sym_set] = ACTIONS(1353), + [anon_sym_new] = ACTIONS(1353), + [sym_const_builtin] = ACTIONS(1353), + [anon_sym_late] = ACTIONS(1353), + [anon_sym_this] = ACTIONS(1353), + [anon_sym_super] = ACTIONS(1353), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(491)] = { + [sym_comment] = STATE(491), + [sym_documentation_comment] = STATE(491), + [sym_identifier] = ACTIONS(1357), + [anon_sym_POUND] = ACTIONS(1359), + [sym_decimal_integer_literal] = ACTIONS(1357), + [sym_hex_integer_literal] = ACTIONS(1359), + [sym_decimal_floating_point_literal] = ACTIONS(1357), + [anon_sym_true] = ACTIONS(1357), + [anon_sym_false] = ACTIONS(1357), + [anon_sym_DQUOTE] = ACTIONS(1357), + [anon_sym_SQUOTE] = ACTIONS(1357), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1359), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1359), + [anon_sym_r_DQUOTE] = ACTIONS(1357), + [anon_sym_r_SQUOTE] = ACTIONS(1357), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1359), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1359), + [anon_sym_LBRACE] = ACTIONS(1359), + [anon_sym_RBRACE] = ACTIONS(1359), + [anon_sym_LBRACK] = ACTIONS(1359), + [anon_sym_null] = ACTIONS(1357), + [anon_sym_LPAREN] = ACTIONS(1359), + [anon_sym_throw] = ACTIONS(1357), + [anon_sym_LT] = ACTIONS(1359), + [sym_increment_operator] = ACTIONS(1359), + [sym_minus_operator] = ACTIONS(1357), + [anon_sym_BANG] = ACTIONS(1359), + [anon_sym_TILDE] = ACTIONS(1359), + [anon_sym_await] = ACTIONS(1357), + [anon_sym_switch] = ACTIONS(1357), + [anon_sym_default] = ACTIONS(1357), + [anon_sym_do] = ACTIONS(1357), + [anon_sym_while] = ACTIONS(1357), + [anon_sym_continue] = ACTIONS(1357), + [anon_sym_yield] = ACTIONS(1357), + [anon_sym_return] = ACTIONS(1357), + [anon_sym_on] = ACTIONS(1357), + [anon_sym_try] = ACTIONS(1357), + [anon_sym_catch] = ACTIONS(1357), + [anon_sym_finally] = ACTIONS(1357), + [anon_sym_if] = ACTIONS(1357), + [anon_sym_case] = ACTIONS(1357), + [anon_sym_else] = ACTIONS(1357), + [anon_sym_for] = ACTIONS(1357), + [anon_sym_AT] = ACTIONS(1359), + [anon_sym_final] = ACTIONS(1357), + [sym_void_type] = ACTIONS(1357), + [anon_sym_var] = ACTIONS(1357), + [sym_break_builtin] = ACTIONS(1357), + [sym_assert_builtin] = ACTIONS(1357), + [sym_rethrow_builtin] = ACTIONS(1357), + [anon_sym_covariant] = ACTIONS(1357), + [anon_sym_Function] = ACTIONS(1357), + [anon_sym_get] = ACTIONS(1357), + [anon_sym_set] = ACTIONS(1357), + [anon_sym_new] = ACTIONS(1357), + [sym_const_builtin] = ACTIONS(1357), + [anon_sym_late] = ACTIONS(1357), + [anon_sym_this] = ACTIONS(1357), + [anon_sym_super] = ACTIONS(1357), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(492)] = { + [sym_comment] = STATE(492), + [sym_documentation_comment] = STATE(492), + [sym_identifier] = ACTIONS(997), + [anon_sym_POUND] = ACTIONS(999), + [sym_decimal_integer_literal] = ACTIONS(997), + [sym_hex_integer_literal] = ACTIONS(999), + [sym_decimal_floating_point_literal] = ACTIONS(997), + [anon_sym_true] = ACTIONS(997), + [anon_sym_false] = ACTIONS(997), + [anon_sym_DQUOTE] = ACTIONS(997), + [anon_sym_SQUOTE] = ACTIONS(997), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_r_DQUOTE] = ACTIONS(997), + [anon_sym_r_SQUOTE] = ACTIONS(997), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(999), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(999), + [anon_sym_LBRACE] = ACTIONS(999), + [anon_sym_RBRACE] = ACTIONS(999), + [anon_sym_LBRACK] = ACTIONS(999), + [anon_sym_null] = ACTIONS(997), + [anon_sym_LPAREN] = ACTIONS(999), + [anon_sym_throw] = ACTIONS(997), + [anon_sym_LT] = ACTIONS(999), + [sym_increment_operator] = ACTIONS(999), + [sym_minus_operator] = ACTIONS(997), + [anon_sym_BANG] = ACTIONS(999), + [anon_sym_TILDE] = ACTIONS(999), + [anon_sym_await] = ACTIONS(997), + [anon_sym_switch] = ACTIONS(997), + [anon_sym_default] = ACTIONS(997), + [anon_sym_do] = ACTIONS(997), + [anon_sym_while] = ACTIONS(997), + [anon_sym_continue] = ACTIONS(997), + [anon_sym_yield] = ACTIONS(997), + [anon_sym_return] = ACTIONS(997), + [anon_sym_on] = ACTIONS(997), + [anon_sym_try] = ACTIONS(997), + [anon_sym_catch] = ACTIONS(997), + [anon_sym_finally] = ACTIONS(997), + [anon_sym_if] = ACTIONS(997), + [anon_sym_case] = ACTIONS(997), + [anon_sym_else] = ACTIONS(997), + [anon_sym_for] = ACTIONS(997), + [anon_sym_AT] = ACTIONS(999), + [anon_sym_final] = ACTIONS(997), + [sym_void_type] = ACTIONS(997), + [anon_sym_var] = ACTIONS(997), + [sym_break_builtin] = ACTIONS(997), + [sym_assert_builtin] = ACTIONS(997), + [sym_rethrow_builtin] = ACTIONS(997), + [anon_sym_covariant] = ACTIONS(997), + [anon_sym_Function] = ACTIONS(997), + [anon_sym_get] = ACTIONS(997), + [anon_sym_set] = ACTIONS(997), + [anon_sym_new] = ACTIONS(997), + [sym_const_builtin] = ACTIONS(997), + [anon_sym_late] = ACTIONS(997), + [anon_sym_this] = ACTIONS(997), + [anon_sym_super] = ACTIONS(997), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, + [STATE(493)] = { + [sym_comment] = STATE(493), + [sym_documentation_comment] = STATE(493), + [sym_identifier] = ACTIONS(1361), + [anon_sym_POUND] = ACTIONS(1363), + [sym_decimal_integer_literal] = ACTIONS(1361), + [sym_hex_integer_literal] = ACTIONS(1363), + [sym_decimal_floating_point_literal] = ACTIONS(1361), + [anon_sym_true] = ACTIONS(1361), + [anon_sym_false] = ACTIONS(1361), + [anon_sym_DQUOTE] = ACTIONS(1361), + [anon_sym_SQUOTE] = ACTIONS(1361), + [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1363), + [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1363), + [anon_sym_r_DQUOTE] = ACTIONS(1361), + [anon_sym_r_SQUOTE] = ACTIONS(1361), + [anon_sym_r_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1363), + [anon_sym_r_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1363), + [anon_sym_LBRACE] = ACTIONS(1363), + [anon_sym_RBRACE] = ACTIONS(1363), + [anon_sym_LBRACK] = ACTIONS(1363), + [anon_sym_null] = ACTIONS(1361), + [anon_sym_LPAREN] = ACTIONS(1363), + [anon_sym_throw] = ACTIONS(1361), + [anon_sym_LT] = ACTIONS(1363), + [sym_increment_operator] = ACTIONS(1363), + [sym_minus_operator] = ACTIONS(1361), + [anon_sym_BANG] = ACTIONS(1363), + [anon_sym_TILDE] = ACTIONS(1363), + [anon_sym_await] = ACTIONS(1361), + [anon_sym_switch] = ACTIONS(1361), + [anon_sym_default] = ACTIONS(1361), + [anon_sym_do] = ACTIONS(1361), + [anon_sym_while] = ACTIONS(1361), + [anon_sym_continue] = ACTIONS(1361), + [anon_sym_yield] = ACTIONS(1361), + [anon_sym_return] = ACTIONS(1361), + [anon_sym_on] = ACTIONS(1361), + [anon_sym_try] = ACTIONS(1361), + [anon_sym_catch] = ACTIONS(1361), + [anon_sym_finally] = ACTIONS(1361), + [anon_sym_if] = ACTIONS(1361), + [anon_sym_case] = ACTIONS(1361), + [anon_sym_else] = ACTIONS(1361), + [anon_sym_for] = ACTIONS(1361), + [anon_sym_AT] = ACTIONS(1363), + [anon_sym_final] = ACTIONS(1361), + [sym_void_type] = ACTIONS(1361), + [anon_sym_var] = ACTIONS(1361), + [sym_break_builtin] = ACTIONS(1361), + [sym_assert_builtin] = ACTIONS(1361), + [sym_rethrow_builtin] = ACTIONS(1361), + [anon_sym_covariant] = ACTIONS(1361), + [anon_sym_Function] = ACTIONS(1361), + [anon_sym_get] = ACTIONS(1361), + [anon_sym_set] = ACTIONS(1361), + [anon_sym_new] = ACTIONS(1361), + [sym_const_builtin] = ACTIONS(1361), + [anon_sym_late] = ACTIONS(1361), + [anon_sym_this] = ACTIONS(1361), + [anon_sym_super] = ACTIONS(1361), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_SLASH_SLASH_SLASH] = ACTIONS(7), + [sym__block_comment] = ACTIONS(9), + [sym__documentation_block_comment] = ACTIONS(11), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1367), 1, + anon_sym_LPAREN, + ACTIONS(1372), 1, + anon_sym_LT, + STATE(507), 1, + aux_sym_cascade_section_repeat1, + STATE(582), 1, + sym_arguments, + STATE(587), 1, + sym_argument_part, + STATE(3255), 1, + sym_type_arguments, + STATE(494), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1370), 18, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1365), 33, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [93] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1377), 1, + anon_sym_LPAREN, + ACTIONS(1382), 1, + anon_sym_LT, + STATE(494), 1, + aux_sym_cascade_section_repeat1, + STATE(582), 1, + sym_arguments, + STATE(587), 1, + sym_argument_part, + STATE(3255), 1, + sym_type_arguments, + STATE(495), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1380), 18, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1375), 33, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [186] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(496), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1387), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1385), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [333] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(497), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1391), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1389), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [480] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(498), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1395), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1393), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [627] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(499), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1397), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [774] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1405), 1, + sym_equality_operator, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(500), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1403), 5, + anon_sym_QMARK, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1401), 20, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [913] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(501), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1410), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1408), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [1060] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(502), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1414), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1412), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [1207] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(503), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1418), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1416), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [1354] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(504), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1422), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1420), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [1501] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(505), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1426), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1424), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + [1648] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(506), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1430), 5, + anon_sym_QMARK, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1428), 21, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [1785] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1440), 1, + anon_sym_LPAREN, + ACTIONS(1445), 1, + anon_sym_LT, + STATE(582), 1, + sym_arguments, + STATE(587), 1, + sym_argument_part, + STATE(3255), 1, + sym_type_arguments, + STATE(507), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat1, + ACTIONS(1443), 18, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1438), 33, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [1876] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1324), 1, + anon_sym_LPAREN, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1337), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1453), 1, + anon_sym_COLON, + ACTIONS(1455), 1, + anon_sym_QMARK, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1448), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(1459), 2, + anon_sym_BANG, + anon_sym_as, + ACTIONS(1462), 2, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + STATE(508), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(1322), 6, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 15, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_QMARK_DOT, + [1988] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1324), 1, + anon_sym_LPAREN, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_QMARK, + ACTIONS(1337), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1468), 1, + anon_sym_COLON, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1465), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(509), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(1322), 8, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [2096] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1470), 1, + anon_sym_LBRACK, + ACTIONS(1473), 1, + anon_sym_QMARK, + ACTIONS(1476), 1, + anon_sym_DOT, + ACTIONS(1479), 1, + anon_sym_QMARK_DOT, + STATE(560), 1, + sym__assignable_selector, + STATE(640), 1, + sym_index_selector, + STATE(644), 1, + sym__cascade_subsection, + STATE(641), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(510), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat2, + ACTIONS(1309), 18, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_async, + ACTIONS(1304), 28, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [2192] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1018), 1, + aux_sym__expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1153), 1, + sym_cascade_section, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1496), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(511), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1271), 11, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [2344] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(512), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1501), 16, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_SEMI, + anon_sym_AT, + ACTIONS(1499), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [2424] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(513), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1505), 16, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_SEMI, + anon_sym_AT, + ACTIONS(1503), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [2504] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1273), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1275), 1, + anon_sym_QMARK, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1279), 1, + anon_sym_PIPE, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1283), 1, + anon_sym_AMP, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(336), 1, + sym_logical_and_operator, + STATE(337), 1, + sym_logical_or_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(834), 1, + aux_sym_logical_or_expression_repeat1, + STATE(835), 1, + aux_sym_logical_and_expression_repeat1, + STATE(840), 1, + aux_sym__if_null_expression, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(939), 1, + sym_cascade_section, + STATE(1011), 1, + aux_sym__expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1507), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(514), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 4, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1271), 12, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_EQ_GT, + anon_sym_when, + [2656] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1324), 1, + anon_sym_LPAREN, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1337), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1453), 1, + anon_sym_COLON, + ACTIONS(1455), 1, + anon_sym_QMARK, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1459), 2, + anon_sym_BANG, + anon_sym_as, + ACTIONS(1462), 2, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1509), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(515), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(1322), 6, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 15, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_QMARK_DOT, + [2768] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1324), 1, + anon_sym_LPAREN, + ACTIONS(1334), 1, + anon_sym_QMARK, + ACTIONS(1337), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1513), 1, + anon_sym_EQ, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(516), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1465), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(1322), 8, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [2874] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1324), 1, + anon_sym_LPAREN, + ACTIONS(1337), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1455), 1, + anon_sym_QMARK, + ACTIONS(1513), 1, + anon_sym_EQ, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1459), 2, + anon_sym_BANG, + anon_sym_as, + ACTIONS(1462), 2, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1509), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(517), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(1322), 7, + anon_sym_LBRACK, + anon_sym_COLON, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 15, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_QMARK_DOT, + [2984] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(518), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1518), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1516), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3063] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(519), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1522), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1520), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3142] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(520), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1526), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1524), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3221] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(521), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1530), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1528), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3300] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(522), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1534), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1532), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3379] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(523), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1153), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1151), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3458] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(524), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1538), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1536), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3537] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(525), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1322), 21, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [3626] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(526), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1542), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1540), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3705] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1548), 1, + anon_sym_else, + STATE(527), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1546), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1544), 39, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3786] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(528), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1552), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1550), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3865] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(529), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1556), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1554), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [3944] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(530), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1560), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1558), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4023] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(531), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1564), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1562), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4102] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(532), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1568), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1566), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4181] = 58, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_final, + ACTIONS(27), 1, + anon_sym_inline, + ACTIONS(29), 1, + anon_sym_class, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(43), 1, + anon_sym_export, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(49), 1, + anon_sym_import, + ACTIONS(51), 1, + anon_sym_interface, + ACTIONS(53), 1, + anon_sym_base, + ACTIONS(55), 1, + anon_sym_abstract, + ACTIONS(57), 1, + anon_sym_sealed, + ACTIONS(59), 1, + anon_sym_mixin, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(63), 1, + anon_sym_typedef, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(1570), 1, + anon_sym_part, + ACTIONS(1572), 1, + anon_sym_enum, + ACTIONS(1574), 1, + anon_sym_extension, + ACTIONS(1576), 1, + anon_sym_library, + ACTIONS(1578), 1, + sym_part_of_builtin, + ACTIONS(1580), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1618), 1, + sym_import_specification, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1847), 1, + sym__export, + STATE(1853), 1, + sym_function_type, + STATE(1855), 1, + sym__external_builtin, + STATE(1866), 1, + sym__import, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1979), 1, + sym__late_builtin, + STATE(2018), 1, + sym_final_builtin, + STATE(2099), 1, + sym__typedef, + STATE(2281), 1, + sym_abstract, + STATE(2407), 1, + sym__get, + STATE(2413), 1, + sym__type, + STATE(2449), 1, + sym__set, + STATE(2740), 1, + sym_inferred_type, + STATE(2761), 1, + sym_base, + STATE(3118), 1, + sym_mixin, + STATE(3166), 1, + sym__class_modifiers, + STATE(3343), 1, + sym__mixin_class_modifiers, + STATE(533), 2, + sym_comment, + sym_documentation_comment, + STATE(3392), 2, + sym_interface, + sym_sealed, + STATE(2216), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [4360] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(534), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1584), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1582), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4439] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(535), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1588), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1586), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4518] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1590), 1, + anon_sym_LPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(536), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1322), 20, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [4609] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(537), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1595), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1593), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4688] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(538), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1599), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1597), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4767] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(539), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1603), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1601), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4846] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(540), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1607), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1605), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [4925] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(541), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1611), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1609), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5004] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(542), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1615), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1613), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5083] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(543), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1619), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1617), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5162] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1625), 1, + anon_sym_else, + STATE(544), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1623), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1621), 39, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5243] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(545), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1629), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1627), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5322] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(546), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1633), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1631), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5401] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(547), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1637), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1635), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5480] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(548), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1641), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1639), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5559] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(549), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1645), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1643), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5638] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(550), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1649), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1647), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5717] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(551), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1653), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1651), 40, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5796] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(552), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1655), 35, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [5874] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(553), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1661), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1659), 39, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_case, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [5952] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(554), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1663), 35, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6030] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(555), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 35, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6108] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1445), 1, + anon_sym_LT, + ACTIONS(1671), 1, + anon_sym_LPAREN, + STATE(639), 1, + sym_argument_part, + STATE(657), 1, + sym_arguments, + STATE(3121), 1, + sym_type_arguments, + STATE(556), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat1, + ACTIONS(1443), 20, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1438), 28, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6196] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1372), 1, + anon_sym_LT, + ACTIONS(1674), 1, + anon_sym_LPAREN, + STATE(556), 1, + aux_sym_cascade_section_repeat1, + STATE(639), 1, + sym_argument_part, + STATE(657), 1, + sym_arguments, + STATE(3121), 1, + sym_type_arguments, + STATE(557), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1370), 20, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1365), 28, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6286] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(558), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1677), 35, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6364] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1683), 1, + anon_sym_EQ, + STATE(559), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1685), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1687), 18, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 21, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6446] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1382), 1, + anon_sym_LT, + ACTIONS(1689), 1, + anon_sym_LPAREN, + STATE(557), 1, + aux_sym_cascade_section_repeat1, + STATE(639), 1, + sym_argument_part, + STATE(657), 1, + sym_arguments, + STATE(3121), 1, + sym_type_arguments, + STATE(560), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1380), 20, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1375), 28, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6536] = 57, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_final, + ACTIONS(27), 1, + anon_sym_inline, + ACTIONS(29), 1, + anon_sym_class, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(43), 1, + anon_sym_export, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(49), 1, + anon_sym_import, + ACTIONS(51), 1, + anon_sym_interface, + ACTIONS(53), 1, + anon_sym_base, + ACTIONS(55), 1, + anon_sym_abstract, + ACTIONS(57), 1, + anon_sym_sealed, + ACTIONS(59), 1, + anon_sym_mixin, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(63), 1, + anon_sym_typedef, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(1570), 1, + anon_sym_part, + ACTIONS(1572), 1, + anon_sym_enum, + ACTIONS(1574), 1, + anon_sym_extension, + ACTIONS(1578), 1, + sym_part_of_builtin, + ACTIONS(1580), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1618), 1, + sym_import_specification, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1847), 1, + sym__export, + STATE(1853), 1, + sym_function_type, + STATE(1855), 1, + sym__external_builtin, + STATE(1866), 1, + sym__import, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1979), 1, + sym__late_builtin, + STATE(2018), 1, + sym_final_builtin, + STATE(2099), 1, + sym__typedef, + STATE(2281), 1, + sym_abstract, + STATE(2407), 1, + sym__get, + STATE(2413), 1, + sym__type, + STATE(2449), 1, + sym__set, + STATE(2740), 1, + sym_inferred_type, + STATE(2761), 1, + sym_base, + STATE(3118), 1, + sym_mixin, + STATE(3166), 1, + sym__class_modifiers, + STATE(3343), 1, + sym__mixin_class_modifiers, + STATE(561), 2, + sym_comment, + sym_documentation_comment, + STATE(3392), 2, + sym_interface, + sym_sealed, + STATE(2216), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [6712] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1694), 1, + anon_sym_EQ, + STATE(562), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1696), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1698), 18, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1692), 21, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [6794] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(563), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1422), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1420), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [6938] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(564), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1397), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [7082] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(1700), 1, + sym_equality_operator, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(565), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1403), 6, + anon_sym_QMARK, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1401), 16, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [7218] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(566), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1414), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1412), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [7362] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(567), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1418), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1416), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [7506] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(568), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1426), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1424), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [7650] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(569), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1430), 6, + anon_sym_QMARK, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1428), 17, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [7784] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(570), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1410), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1408), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [7928] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(571), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1395), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1393), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [8072] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(572), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1705), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_QMARK_DOT, + anon_sym_AT, + ACTIONS(1703), 39, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + anon_sym_QMARK, + sym_minus_operator, + anon_sym_await, + anon_sym_DOT, + anon_sym_switch, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [8150] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(573), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1387), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1385), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [8294] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(574), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1707), 35, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [8372] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1482), 1, + anon_sym_QMARK_QMARK, + ACTIONS(1484), 1, + anon_sym_QMARK, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1488), 1, + anon_sym_PIPE, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(1492), 1, + anon_sym_AMP, + ACTIONS(1494), 1, + anon_sym_as, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(369), 1, + sym_logical_and_operator, + STATE(370), 1, + sym_logical_or_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1020), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1021), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1061), 1, + aux_sym__if_null_expression, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1109), 1, + sym_type_test, + STATE(1110), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(2100), 1, + sym_is_operator, + STATE(2127), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(575), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1391), 5, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1389), 13, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [8516] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1711), 1, + anon_sym_EQ, + STATE(576), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1713), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1687), 18, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 21, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [8598] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1717), 1, + anon_sym_RBRACE, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + STATE(596), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(577), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [8771] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(578), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1707), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [8848] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1727), 1, + anon_sym_RBRACE, + STATE(583), 1, + aux_sym_extension_body_repeat1, + STATE(685), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2437), 1, + sym_method_signature, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3153), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(579), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [9021] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1729), 1, + anon_sym_RBRACE, + STATE(591), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(580), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [9194] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1729), 1, + anon_sym_RBRACE, + STATE(585), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(581), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [9367] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(582), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1731), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [9444] = 55, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1735), 1, + sym_identifier, + ACTIONS(1738), 1, + anon_sym_RBRACE, + ACTIONS(1740), 1, + anon_sym_LPAREN, + ACTIONS(1743), 1, + anon_sym_AT, + ACTIONS(1746), 1, + anon_sym_final, + ACTIONS(1749), 1, + sym_void_type, + ACTIONS(1752), 1, + anon_sym_var, + ACTIONS(1755), 1, + anon_sym_covariant, + ACTIONS(1758), 1, + anon_sym_factory, + ACTIONS(1761), 1, + anon_sym_Function, + ACTIONS(1764), 1, + anon_sym_get, + ACTIONS(1767), 1, + anon_sym_operator, + ACTIONS(1770), 1, + anon_sym_set, + ACTIONS(1773), 1, + anon_sym_static, + ACTIONS(1776), 1, + sym_const_builtin, + ACTIONS(1779), 1, + anon_sym_late, + ACTIONS(1782), 1, + anon_sym_external, + STATE(685), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2437), 1, + sym_method_signature, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3153), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(583), 3, + sym_comment, + sym_documentation_comment, + aux_sym_extension_body_repeat1, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [9615] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(584), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1787), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1785), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [9692] = 55, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1789), 1, + sym_identifier, + ACTIONS(1792), 1, + anon_sym_RBRACE, + ACTIONS(1794), 1, + anon_sym_LPAREN, + ACTIONS(1797), 1, + anon_sym_AT, + ACTIONS(1800), 1, + anon_sym_final, + ACTIONS(1803), 1, + sym_void_type, + ACTIONS(1806), 1, + anon_sym_var, + ACTIONS(1809), 1, + anon_sym_covariant, + ACTIONS(1812), 1, + anon_sym_factory, + ACTIONS(1815), 1, + anon_sym_Function, + ACTIONS(1818), 1, + anon_sym_get, + ACTIONS(1821), 1, + anon_sym_operator, + ACTIONS(1824), 1, + anon_sym_set, + ACTIONS(1827), 1, + anon_sym_static, + ACTIONS(1830), 1, + sym_const_builtin, + ACTIONS(1833), 1, + anon_sym_late, + ACTIONS(1836), 1, + anon_sym_external, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(585), 3, + sym_comment, + sym_documentation_comment, + aux_sym_enum_body_repeat2, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [9863] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(586), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1841), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1839), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [9940] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(587), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1845), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1843), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10017] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(588), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1849), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1847), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10094] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1851), 1, + anon_sym_RBRACE, + STATE(597), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(589), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [10267] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(710), 1, + anon_sym_DQUOTE, + ACTIONS(712), 1, + anon_sym_SQUOTE, + ACTIONS(714), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(716), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(718), 1, + anon_sym_r_DQUOTE, + ACTIONS(720), 1, + anon_sym_r_SQUOTE, + ACTIONS(722), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(724), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(594), 1, + aux_sym_string_literal_repeat1, + STATE(590), 2, + sym_comment, + sym_documentation_comment, + STATE(747), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1267), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1265), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10364] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1717), 1, + anon_sym_RBRACE, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + STATE(585), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(591), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [10537] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(592), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10614] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(593), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1853), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10691] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1857), 1, + anon_sym_DQUOTE, + ACTIONS(1860), 1, + anon_sym_SQUOTE, + ACTIONS(1863), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1866), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(1869), 1, + anon_sym_r_DQUOTE, + ACTIONS(1872), 1, + anon_sym_r_SQUOTE, + ACTIONS(1875), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1878), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(594), 3, + sym_comment, + sym_documentation_comment, + aux_sym_string_literal_repeat1, + STATE(747), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1263), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1261), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [10786] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1881), 1, + anon_sym_RBRACE, + STATE(579), 1, + aux_sym_extension_body_repeat1, + STATE(685), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2437), 1, + sym_method_signature, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3153), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(595), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [10959] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1883), 1, + anon_sym_RBRACE, + STATE(585), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(596), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [11132] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1885), 1, + anon_sym_RBRACE, + STATE(585), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(597), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [11305] = 56, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + ACTIONS(1887), 1, + anon_sym_RBRACE, + STATE(581), 1, + aux_sym_enum_body_repeat2, + STATE(701), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2360), 1, + sym_method_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3129), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(598), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [11478] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(599), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1889), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [11555] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(600), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1893), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [11632] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(601), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1677), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [11709] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(602), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1655), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [11786] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(603), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 19, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1663), 34, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [11863] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(604), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1899), 15, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_DOT_DOT_DOT, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_AT, + ACTIONS(1897), 37, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_do, + anon_sym_while, + anon_sym_continue, + anon_sym_yield, + anon_sym_return, + anon_sym_try, + anon_sym_if, + anon_sym_for, + anon_sym_final, + sym_void_type, + anon_sym_var, + sym_break_builtin, + sym_assert_builtin, + sym_rethrow_builtin, + anon_sym_covariant, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [11939] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1590), 1, + anon_sym_LPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(605), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1322), 15, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1332), 18, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_async, + [12027] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(606), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1322), 16, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1332), 18, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_async, + [12113] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(607), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1901), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1903), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12188] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(608), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1905), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1907), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12263] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1711), 1, + anon_sym_EQ, + STATE(609), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1713), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1681), 16, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1687), 20, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + [12342] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1694), 1, + anon_sym_EQ, + STATE(610), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1696), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1692), 16, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1698), 20, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + [12421] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1683), 1, + anon_sym_EQ, + STATE(611), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1685), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1681), 16, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1687), 20, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + [12500] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(612), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1677), 30, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12575] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(613), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1655), 30, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12650] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(614), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1663), 30, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12725] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(615), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1667), 30, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12800] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(616), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1707), 30, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12875] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1912), 1, + anon_sym_LPAREN, + ACTIONS(1915), 1, + anon_sym_EQ, + ACTIONS(1918), 1, + anon_sym_LT, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2536), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1909), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(617), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 17, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 25, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [12966] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(618), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1921), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1923), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13041] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(619), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1925), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1927), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13116] = 29, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1929), 1, + sym_identifier, + ACTIONS(1936), 1, + anon_sym_LPAREN, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(1941), 1, + anon_sym_GT, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2741), 1, + sym_type_parameter, + STATE(2913), 1, + sym__type, + STATE(620), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1932), 12, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(1934), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + [13233] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1455), 1, + anon_sym_QMARK, + ACTIONS(1590), 1, + anon_sym_LPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1459), 2, + anon_sym_BANG, + anon_sym_as, + STATE(621), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1462), 5, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1322), 7, + anon_sym_LBRACK, + anon_sym_COLON, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 15, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_QMARK_DOT, + [13328] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(622), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1943), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1945), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13403] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(623), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1947), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1949), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13478] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1912), 1, + anon_sym_LPAREN, + ACTIONS(1915), 1, + anon_sym_EQ, + ACTIONS(1918), 1, + anon_sym_LT, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2536), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(624), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1909), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + ACTIONS(1669), 17, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 24, + anon_sym_LBRACK, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13569] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(625), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1951), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1953), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13644] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(626), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1955), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1957), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13719] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(627), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1959), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1961), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13794] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(628), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1963), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1965), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13869] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(629), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1967), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1969), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [13944] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(784), 1, + anon_sym_DQUOTE, + ACTIONS(786), 1, + anon_sym_SQUOTE, + ACTIONS(788), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(790), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(792), 1, + anon_sym_r_DQUOTE, + ACTIONS(794), 1, + anon_sym_r_SQUOTE, + ACTIONS(796), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(798), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(631), 1, + aux_sym_string_literal_repeat1, + STATE(630), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1267), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + STATE(808), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1265), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14039] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1971), 1, + anon_sym_DQUOTE, + ACTIONS(1974), 1, + anon_sym_SQUOTE, + ACTIONS(1977), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1980), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(1983), 1, + anon_sym_r_DQUOTE, + ACTIONS(1986), 1, + anon_sym_r_SQUOTE, + ACTIONS(1989), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1992), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(631), 3, + sym_comment, + sym_documentation_comment, + aux_sym_string_literal_repeat1, + ACTIONS(1263), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + STATE(808), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1261), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14132] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(632), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1995), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1997), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14207] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(633), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1999), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2001), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14282] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(634), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2003), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2005), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14357] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(635), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2007), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2009), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14432] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(636), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2011), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2013), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14507] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(637), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2015), 14, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2017), 37, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_if, + anon_sym_case, + anon_sym_else, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14582] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2021), 1, + anon_sym_LBRACK, + ACTIONS(2024), 1, + anon_sym_LPAREN, + ACTIONS(2027), 1, + anon_sym_QMARK, + ACTIONS(2030), 1, + anon_sym_LT, + ACTIONS(2035), 1, + anon_sym_BANG, + ACTIONS(2038), 1, + anon_sym_DOT, + ACTIONS(2041), 1, + anon_sym_QMARK_DOT, + STATE(665), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(846), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(638), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14688] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(639), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1845), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1843), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14762] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(640), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1677), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14836] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(641), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1655), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [14910] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1468), 1, + anon_sym_COLON, + ACTIONS(2044), 1, + anon_sym_RPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1334), 2, + anon_sym_QMARK, + anon_sym_LT, + ACTIONS(1590), 2, + anon_sym_COMMA, + anon_sym_LPAREN, + STATE(642), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 8, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [15002] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2052), 1, + anon_sym_QMARK, + ACTIONS(2054), 1, + anon_sym_LT, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2060), 1, + anon_sym_DOT, + ACTIONS(2062), 1, + anon_sym_QMARK_DOT, + STATE(558), 1, + sym_index_selector, + STATE(576), 1, + sym__assignable_selector, + STATE(666), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(643), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2046), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15108] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(644), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1841), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1839), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15182] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(645), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1663), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15256] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2024), 1, + anon_sym_LPAREN, + ACTIONS(2030), 1, + anon_sym_LT, + ACTIONS(2035), 1, + anon_sym_BANG, + ACTIONS(2064), 1, + anon_sym_LBRACK, + ACTIONS(2067), 1, + anon_sym_QMARK, + ACTIONS(2070), 1, + anon_sym_DOT, + ACTIONS(2073), 1, + anon_sym_QMARK_DOT, + STATE(558), 1, + sym_index_selector, + STATE(576), 1, + sym__assignable_selector, + STATE(675), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(646), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15362] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1912), 1, + anon_sym_LPAREN, + ACTIONS(1918), 1, + anon_sym_LT, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2536), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1909), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(647), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 18, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 24, + anon_sym_LBRACK, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15450] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1468), 1, + anon_sym_COLON, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1334), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(648), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1590), 3, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + ACTIONS(1322), 8, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [15540] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(649), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1667), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15614] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(650), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1707), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15688] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1590), 1, + anon_sym_LPAREN, + ACTIONS(2076), 1, + anon_sym_in, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1334), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(651), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 10, + anon_sym_LBRACK, + anon_sym_COMMA, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [15778] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(2078), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(652), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 15, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1322), 17, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15862] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(653), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1893), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [15936] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2054), 1, + anon_sym_LT, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2084), 1, + anon_sym_QMARK, + ACTIONS(2086), 1, + anon_sym_DOT, + ACTIONS(2088), 1, + anon_sym_QMARK_DOT, + STATE(668), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(846), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(654), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2046), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16042] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(655), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1849), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1847), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16116] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1590), 1, + anon_sym_LPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1334), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(656), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 11, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_COLON, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [16204] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(657), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1731), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16278] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(658), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1853), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16352] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(659), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1787), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1785), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16426] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(660), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 21, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1889), 29, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16500] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(661), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 17, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1707), 32, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16573] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1711), 1, + anon_sym_EQ, + STATE(662), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1713), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1687), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1681), 18, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16650] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2027), 1, + anon_sym_QMARK, + ACTIONS(2030), 1, + anon_sym_LT, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2086), 1, + anon_sym_DOT, + ACTIONS(2088), 1, + anon_sym_QMARK_DOT, + STATE(680), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(846), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(663), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16755] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1694), 1, + anon_sym_EQ, + STATE(664), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1696), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1698), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1692), 18, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16832] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2092), 1, + anon_sym_LBRACK, + ACTIONS(2095), 1, + anon_sym_LPAREN, + ACTIONS(2098), 1, + anon_sym_QMARK, + ACTIONS(2101), 1, + anon_sym_LT, + ACTIONS(2106), 1, + anon_sym_BANG, + ACTIONS(2109), 1, + anon_sym_DOT, + ACTIONS(2112), 1, + anon_sym_QMARK_DOT, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(854), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(665), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [16935] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2052), 1, + anon_sym_QMARK, + ACTIONS(2054), 1, + anon_sym_LT, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2060), 1, + anon_sym_DOT, + ACTIONS(2062), 1, + anon_sym_QMARK_DOT, + STATE(558), 1, + sym_index_selector, + STATE(559), 1, + sym__assignable_selector, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(666), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17038] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2121), 1, + anon_sym_LBRACK, + ACTIONS(2124), 1, + anon_sym_LPAREN, + ACTIONS(2127), 1, + anon_sym_QMARK, + ACTIONS(2130), 1, + anon_sym_LT, + ACTIONS(2135), 1, + anon_sym_BANG, + ACTIONS(2138), 1, + anon_sym_DOT, + ACTIONS(2141), 1, + anon_sym_QMARK_DOT, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(999), 1, + sym_index_selector, + STATE(1006), 1, + sym_selector, + STATE(1000), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(667), 3, + sym_comment, + sym_documentation_comment, + aux_sym__assignable_selector_part_repeat1, + STATE(901), 3, + sym__exclamation_operator, + sym_argument_part, + sym__assignable_selector, + ACTIONS(2133), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2119), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17137] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2054), 1, + anon_sym_LT, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2084), 1, + anon_sym_QMARK, + ACTIONS(2086), 1, + anon_sym_DOT, + ACTIONS(2088), 1, + anon_sym_QMARK_DOT, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(854), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(668), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17240] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(669), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 17, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1663), 32, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17313] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(670), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 17, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1667), 32, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17386] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2030), 1, + anon_sym_LT, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2060), 1, + anon_sym_DOT, + ACTIONS(2062), 1, + anon_sym_QMARK_DOT, + ACTIONS(2067), 1, + anon_sym_QMARK, + STATE(558), 1, + sym_index_selector, + STATE(576), 1, + sym__assignable_selector, + STATE(679), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(671), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17491] = 52, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_final, + ACTIONS(27), 1, + anon_sym_inline, + ACTIONS(29), 1, + anon_sym_class, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(51), 1, + anon_sym_interface, + ACTIONS(53), 1, + anon_sym_base, + ACTIONS(55), 1, + anon_sym_abstract, + ACTIONS(57), 1, + anon_sym_sealed, + ACTIONS(59), 1, + anon_sym_mixin, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(63), 1, + anon_sym_typedef, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(1570), 1, + anon_sym_part, + ACTIONS(1572), 1, + anon_sym_enum, + ACTIONS(1574), 1, + anon_sym_extension, + ACTIONS(1578), 1, + sym_part_of_builtin, + ACTIONS(1580), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1855), 1, + sym__external_builtin, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1979), 1, + sym__late_builtin, + STATE(2018), 1, + sym_final_builtin, + STATE(2099), 1, + sym__typedef, + STATE(2281), 1, + sym_abstract, + STATE(2407), 1, + sym__get, + STATE(2413), 1, + sym__type, + STATE(2449), 1, + sym__set, + STATE(2740), 1, + sym_inferred_type, + STATE(2761), 1, + sym_base, + STATE(3118), 1, + sym_mixin, + STATE(3166), 1, + sym__class_modifiers, + STATE(3343), 1, + sym__mixin_class_modifiers, + STATE(672), 2, + sym_comment, + sym_documentation_comment, + STATE(3392), 2, + sym_interface, + sym_sealed, + STATE(2216), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [17652] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1683), 1, + anon_sym_EQ, + STATE(673), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1685), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1687), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1681), 18, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17729] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(939), 1, + sym_cascade_section, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2115), 1, + aux_sym__expression_repeat1, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(674), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1271), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [17872] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2095), 1, + anon_sym_LPAREN, + ACTIONS(2101), 1, + anon_sym_LT, + ACTIONS(2106), 1, + anon_sym_BANG, + ACTIONS(2158), 1, + anon_sym_LBRACK, + ACTIONS(2161), 1, + anon_sym_QMARK, + ACTIONS(2164), 1, + anon_sym_DOT, + ACTIONS(2167), 1, + anon_sym_QMARK_DOT, + STATE(558), 1, + sym_index_selector, + STATE(559), 1, + sym__assignable_selector, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(675), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [17975] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(676), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 17, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1677), 32, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [18048] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(2044), 1, + anon_sym_COMMA, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(1334), 2, + anon_sym_QMARK, + anon_sym_LT, + ACTIONS(1590), 2, + anon_sym_LPAREN, + anon_sym_RPAREN, + STATE(677), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 8, + anon_sym_LBRACK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 17, + anon_sym_QMARK_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + [18137] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(678), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 17, + anon_sym_EQ, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + ACTIONS(1655), 32, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [18210] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2060), 1, + anon_sym_DOT, + ACTIONS(2062), 1, + anon_sym_QMARK_DOT, + ACTIONS(2101), 1, + anon_sym_LT, + ACTIONS(2161), 1, + anon_sym_QMARK, + STATE(558), 1, + sym_index_selector, + STATE(559), 1, + sym__assignable_selector, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(552), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(679), 2, + sym_comment, + sym_documentation_comment, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [18312] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(2058), 1, + anon_sym_BANG, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2086), 1, + anon_sym_DOT, + ACTIONS(2088), 1, + anon_sym_QMARK_DOT, + ACTIONS(2098), 1, + anon_sym_QMARK, + ACTIONS(2101), 1, + anon_sym_LT, + STATE(667), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(854), 1, + sym__assignable_selector, + STATE(863), 1, + sym_type_arguments, + STATE(906), 1, + sym_arguments, + STATE(1006), 1, + sym_selector, + STATE(680), 2, + sym_comment, + sym_documentation_comment, + STATE(845), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(901), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [18414] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1328), 1, + anon_sym_EQ, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(1468), 1, + anon_sym_COLON, + ACTIONS(1590), 1, + anon_sym_LPAREN, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(681), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 12, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1330), 14, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + ACTIONS(1332), 16, + anon_sym_QMARK_QMARK, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + [18500] = 51, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_final, + ACTIONS(27), 1, + anon_sym_inline, + ACTIONS(29), 1, + anon_sym_class, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(51), 1, + anon_sym_interface, + ACTIONS(53), 1, + anon_sym_base, + ACTIONS(55), 1, + anon_sym_abstract, + ACTIONS(57), 1, + anon_sym_sealed, + ACTIONS(59), 1, + anon_sym_mixin, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(63), 1, + anon_sym_typedef, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(1572), 1, + anon_sym_enum, + ACTIONS(1574), 1, + anon_sym_extension, + ACTIONS(1578), 1, + sym_part_of_builtin, + ACTIONS(1580), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1855), 1, + sym__external_builtin, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1979), 1, + sym__late_builtin, + STATE(2018), 1, + sym_final_builtin, + STATE(2099), 1, + sym__typedef, + STATE(2281), 1, + sym_abstract, + STATE(2407), 1, + sym__get, + STATE(2413), 1, + sym__type, + STATE(2449), 1, + sym__set, + STATE(2740), 1, + sym_inferred_type, + STATE(2761), 1, + sym_base, + STATE(3118), 1, + sym_mixin, + STATE(3166), 1, + sym__class_modifiers, + STATE(3343), 1, + sym__mixin_class_modifiers, + STATE(682), 2, + sym_comment, + sym_documentation_comment, + STATE(3392), 2, + sym_interface, + sym_sealed, + STATE(2216), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [18658] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1430), 1, + anon_sym_QMARK, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(683), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1428), 15, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [18785] = 50, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_final, + ACTIONS(27), 1, + anon_sym_inline, + ACTIONS(29), 1, + anon_sym_class, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(51), 1, + anon_sym_interface, + ACTIONS(53), 1, + anon_sym_base, + ACTIONS(55), 1, + anon_sym_abstract, + ACTIONS(57), 1, + anon_sym_sealed, + ACTIONS(59), 1, + anon_sym_mixin, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(63), 1, + anon_sym_typedef, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(1572), 1, + anon_sym_enum, + ACTIONS(1574), 1, + anon_sym_extension, + ACTIONS(1580), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1855), 1, + sym__external_builtin, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1979), 1, + sym__late_builtin, + STATE(2018), 1, + sym_final_builtin, + STATE(2099), 1, + sym__typedef, + STATE(2281), 1, + sym_abstract, + STATE(2407), 1, + sym__get, + STATE(2413), 1, + sym__type, + STATE(2449), 1, + sym__set, + STATE(2740), 1, + sym_inferred_type, + STATE(2761), 1, + sym_base, + STATE(3118), 1, + sym_mixin, + STATE(3166), 1, + sym__class_modifiers, + STATE(3343), 1, + sym__mixin_class_modifiers, + STATE(684), 2, + sym_comment, + sym_documentation_comment, + STATE(3392), 2, + sym_interface, + sym_sealed, + STATE(2216), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [18940] = 50, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2399), 1, + sym_method_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3119), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(685), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [19095] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(686), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1385), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [19230] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + ACTIONS(2186), 1, + anon_sym_async, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(1987), 1, + sym_cascade_section, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + STATE(2171), 1, + aux_sym__expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2184), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(687), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2170), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [19373] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(688), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1408), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [19508] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2192), 1, + anon_sym_QMARK, + ACTIONS(2195), 1, + anon_sym_LT, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2200), 1, + anon_sym_DOT, + ACTIONS(2202), 1, + anon_sym_QMARK_DOT, + STATE(609), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(708), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(689), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2019), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [19611] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2195), 1, + anon_sym_LT, + ACTIONS(2204), 1, + anon_sym_LBRACK, + ACTIONS(2207), 1, + anon_sym_LPAREN, + ACTIONS(2210), 1, + anon_sym_QMARK, + ACTIONS(2213), 1, + anon_sym_BANG, + ACTIONS(2216), 1, + anon_sym_DOT, + ACTIONS(2219), 1, + anon_sym_QMARK_DOT, + STATE(710), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1036), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(690), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2019), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [19714] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2192), 1, + anon_sym_QMARK, + ACTIONS(2195), 1, + anon_sym_LT, + ACTIONS(2207), 1, + anon_sym_LPAREN, + ACTIONS(2213), 1, + anon_sym_BANG, + ACTIONS(2222), 1, + anon_sym_LBRACK, + ACTIONS(2225), 1, + anon_sym_DOT, + ACTIONS(2228), 1, + anon_sym_QMARK_DOT, + STATE(609), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(705), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(691), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2019), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [19817] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(692), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1420), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [19952] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(693), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1416), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [20087] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2233), 1, + anon_sym_QMARK, + ACTIONS(2235), 1, + anon_sym_LT, + ACTIONS(2237), 1, + anon_sym_DOT, + ACTIONS(2239), 1, + anon_sym_QMARK_DOT, + STATE(707), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1036), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(694), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2046), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [20190] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + ACTIONS(2243), 1, + anon_sym_async, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(1987), 1, + sym_cascade_section, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + STATE(2164), 1, + aux_sym__expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2184), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(695), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2241), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [20333] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(696), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1424), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [20468] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(697), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1393), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [20603] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2195), 1, + anon_sym_LT, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2210), 1, + anon_sym_QMARK, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2237), 1, + anon_sym_DOT, + ACTIONS(2239), 1, + anon_sym_QMARK_DOT, + STATE(711), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1036), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(698), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2019), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [20706] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2200), 1, + anon_sym_DOT, + ACTIONS(2202), 1, + anon_sym_QMARK_DOT, + ACTIONS(2235), 1, + anon_sym_LT, + ACTIONS(2245), 1, + anon_sym_QMARK, + STATE(609), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(709), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(699), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2046), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [20809] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(700), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1389), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [20944] = 50, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(69), 1, + anon_sym_external, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(1715), 1, + sym_identifier, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(1725), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1536), 1, + sym__operator, + STATE(1563), 1, + sym__static, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1630), 1, + sym__external, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1824), 1, + sym__external_builtin, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1919), 1, + sym__external_and_static, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1943), 1, + sym__late_builtin, + STATE(1972), 1, + sym__covariant, + STATE(2010), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2245), 1, + sym_constructor_signature, + STATE(2398), 1, + sym_factory_constructor_signature, + STATE(2401), 1, + sym__type, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2460), 1, + sym_method_signature, + STATE(2653), 1, + sym_constant_constructor_signature, + STATE(2791), 1, + sym__var_or_type, + STATE(3285), 1, + sym_declaration, + STATE(3439), 1, + sym__factory, + STATE(3544), 1, + sym_redirecting_factory_constructor_signature, + STATE(701), 2, + sym_comment, + sym_documentation_comment, + STATE(2546), 4, + sym_getter_signature, + sym_setter_signature, + sym_operator_signature, + sym_function_signature, + [21099] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(702), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1397), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [21234] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1403), 1, + anon_sym_QMARK, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + ACTIONS(2247), 1, + sym_equality_operator, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(703), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1401), 14, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [21363] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(704), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1412), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [21498] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2250), 1, + anon_sym_LBRACK, + ACTIONS(2253), 1, + anon_sym_LPAREN, + ACTIONS(2256), 1, + anon_sym_QMARK, + ACTIONS(2259), 1, + anon_sym_LT, + ACTIONS(2262), 1, + anon_sym_BANG, + ACTIONS(2265), 1, + anon_sym_DOT, + ACTIONS(2268), 1, + anon_sym_QMARK_DOT, + STATE(611), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(705), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2090), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [21598] = 49, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(442), 1, + anon_sym_RPAREN, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2273), 1, + anon_sym_LBRACE, + ACTIONS(2275), 1, + anon_sym_LBRACK, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(2985), 1, + sym_formal_parameter, + STATE(3210), 1, + sym__normal_formal_parameters, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(3448), 1, + sym_optional_formal_parameters, + STATE(706), 2, + sym_comment, + sym_documentation_comment, + STATE(3481), 2, + sym__optional_postional_formal_parameters, + sym__named_formal_parameters, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [21750] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2233), 1, + anon_sym_QMARK, + ACTIONS(2235), 1, + anon_sym_LT, + ACTIONS(2237), 1, + anon_sym_DOT, + ACTIONS(2239), 1, + anon_sym_QMARK_DOT, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1038), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(707), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2115), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [21850] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2200), 1, + anon_sym_DOT, + ACTIONS(2202), 1, + anon_sym_QMARK_DOT, + ACTIONS(2256), 1, + anon_sym_QMARK, + ACTIONS(2259), 1, + anon_sym_LT, + STATE(611), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(708), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2090), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [21950] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2200), 1, + anon_sym_DOT, + ACTIONS(2202), 1, + anon_sym_QMARK_DOT, + ACTIONS(2235), 1, + anon_sym_LT, + ACTIONS(2245), 1, + anon_sym_QMARK, + STATE(611), 1, + sym__assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(613), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(709), 2, + sym_comment, + sym_documentation_comment, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2115), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22050] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2253), 1, + anon_sym_LPAREN, + ACTIONS(2259), 1, + anon_sym_LT, + ACTIONS(2262), 1, + anon_sym_BANG, + ACTIONS(2279), 1, + anon_sym_LBRACK, + ACTIONS(2282), 1, + anon_sym_QMARK, + ACTIONS(2285), 1, + anon_sym_DOT, + ACTIONS(2288), 1, + anon_sym_QMARK_DOT, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1038), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(710), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2090), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22150] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(2198), 1, + anon_sym_BANG, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2237), 1, + anon_sym_DOT, + ACTIONS(2239), 1, + anon_sym_QMARK_DOT, + ACTIONS(2259), 1, + anon_sym_LT, + ACTIONS(2282), 1, + anon_sym_QMARK, + STATE(712), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1038), 1, + sym__assignable_selector, + STATE(1039), 1, + sym_type_arguments, + STATE(1041), 1, + sym_index_selector, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(711), 2, + sym_comment, + sym_documentation_comment, + STATE(1042), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1204), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2090), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22250] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2291), 1, + anon_sym_LBRACK, + ACTIONS(2294), 1, + anon_sym_LPAREN, + ACTIONS(2297), 1, + anon_sym_QMARK, + ACTIONS(2300), 1, + anon_sym_LT, + ACTIONS(2303), 1, + anon_sym_BANG, + ACTIONS(2306), 1, + anon_sym_DOT, + ACTIONS(2309), 1, + anon_sym_QMARK_DOT, + STATE(1039), 1, + sym_type_arguments, + STATE(1141), 1, + sym_arguments, + STATE(1154), 1, + sym_selector, + STATE(1169), 1, + sym_index_selector, + STATE(1090), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(712), 3, + sym_comment, + sym_documentation_comment, + aux_sym__assignable_selector_part_repeat1, + STATE(1204), 3, + sym__exclamation_operator, + sym_argument_part, + sym__assignable_selector, + ACTIONS(2133), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2119), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22346] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1418), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(713), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1416), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [22481] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1410), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(714), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1408), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [22616] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1414), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(715), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1412), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [22751] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2312), 1, + anon_sym_LBRACK, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2316), 1, + anon_sym_QMARK, + ACTIONS(2319), 1, + anon_sym_LT, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2324), 1, + anon_sym_DOT, + ACTIONS(2326), 1, + anon_sym_QMARK_DOT, + STATE(662), 1, + sym__assignable_selector, + STATE(676), 1, + sym_index_selector, + STATE(744), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(678), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(716), 2, + sym_comment, + sym_documentation_comment, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22852] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2312), 1, + anon_sym_LBRACK, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2324), 1, + anon_sym_DOT, + ACTIONS(2326), 1, + anon_sym_QMARK_DOT, + ACTIONS(2328), 1, + anon_sym_QMARK, + ACTIONS(2330), 1, + anon_sym_LT, + STATE(662), 1, + sym__assignable_selector, + STATE(676), 1, + sym_index_selector, + STATE(745), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(678), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(717), 2, + sym_comment, + sym_documentation_comment, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2046), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [22953] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1395), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(718), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1393), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23088] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1426), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(719), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1424), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23223] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1422), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(720), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1420), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23358] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1399), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(721), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1397), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23493] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1987), 1, + sym_cascade_section, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + STATE(2163), 1, + aux_sym__expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1271), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2344), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(722), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [23634] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1387), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(723), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1385), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23769] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1391), 1, + anon_sym_async, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2172), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2174), 1, + anon_sym_QMARK, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(724), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1389), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [23904] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + ACTIONS(2346), 1, + sym_equality_operator, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1403), 2, + anon_sym_QMARK, + anon_sym_async, + STATE(725), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1401), 11, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24031] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2319), 1, + anon_sym_LT, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2351), 1, + anon_sym_QMARK, + ACTIONS(2354), 1, + anon_sym_DOT, + ACTIONS(2356), 1, + anon_sym_QMARK_DOT, + STATE(735), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1206), 1, + sym_index_selector, + STATE(1210), 1, + sym__assignable_selector, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(726), 2, + sym_comment, + sym_documentation_comment, + STATE(1207), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2033), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24132] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2330), 1, + anon_sym_LT, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2354), 1, + anon_sym_DOT, + ACTIONS(2356), 1, + anon_sym_QMARK_DOT, + ACTIONS(2358), 1, + anon_sym_QMARK, + STATE(736), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1206), 1, + sym_index_selector, + STATE(1210), 1, + sym__assignable_selector, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(2011), 1, + sym__assignable_selector_part, + STATE(727), 2, + sym_comment, + sym_documentation_comment, + STATE(1207), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2056), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2046), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24233] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1494), 1, + anon_sym_as, + ACTIONS(2178), 1, + anon_sym_PIPE, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2182), 1, + anon_sym_AMP, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(354), 1, + sym_logical_and_operator, + STATE(355), 1, + sym_logical_or_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1465), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1466), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1550), 1, + aux_sym__if_null_expression, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1609), 1, + sym_type_test, + STATE(1611), 1, + sym_type_cast, + STATE(2091), 1, + sym_is_operator, + STATE(2092), 1, + sym_as_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1430), 2, + anon_sym_QMARK, + anon_sym_async, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(728), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1428), 12, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24358] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(729), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1995), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1997), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24426] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(730), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1959), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1961), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24494] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(731), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1963), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1965), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24562] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(732), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1967), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1969), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24630] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(733), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1921), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1923), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24698] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(734), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1925), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1927), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24766] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2354), 1, + anon_sym_DOT, + ACTIONS(2356), 1, + anon_sym_QMARK_DOT, + ACTIONS(2360), 1, + anon_sym_QMARK, + ACTIONS(2363), 1, + anon_sym_LT, + STATE(746), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1206), 1, + sym_index_selector, + STATE(1212), 1, + sym__assignable_selector, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(735), 2, + sym_comment, + sym_documentation_comment, + STATE(1207), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24864] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2330), 1, + anon_sym_LT, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2354), 1, + anon_sym_DOT, + ACTIONS(2356), 1, + anon_sym_QMARK_DOT, + ACTIONS(2358), 1, + anon_sym_QMARK, + STATE(746), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1206), 1, + sym_index_selector, + STATE(1212), 1, + sym__assignable_selector, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(736), 2, + sym_comment, + sym_documentation_comment, + STATE(1207), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [24962] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(737), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1999), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2001), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25030] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(738), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2003), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2005), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25098] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(739), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2007), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2009), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25166] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(740), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1901), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1903), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25234] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(741), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2011), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2013), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25302] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(742), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2015), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2017), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25370] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(743), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1905), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1907), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25438] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2312), 1, + anon_sym_LBRACK, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2324), 1, + anon_sym_DOT, + ACTIONS(2326), 1, + anon_sym_QMARK_DOT, + ACTIONS(2363), 1, + anon_sym_LT, + ACTIONS(2366), 1, + anon_sym_QMARK, + STATE(673), 1, + sym__assignable_selector, + STATE(676), 1, + sym_index_selector, + STATE(746), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(678), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(744), 2, + sym_comment, + sym_documentation_comment, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2104), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2090), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25536] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2312), 1, + anon_sym_LBRACK, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(2322), 1, + anon_sym_BANG, + ACTIONS(2324), 1, + anon_sym_DOT, + ACTIONS(2326), 1, + anon_sym_QMARK_DOT, + ACTIONS(2328), 1, + anon_sym_QMARK, + ACTIONS(2330), 1, + anon_sym_LT, + STATE(673), 1, + sym__assignable_selector, + STATE(676), 1, + sym_index_selector, + STATE(746), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(1205), 1, + sym_type_arguments, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(678), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(745), 2, + sym_comment, + sym_documentation_comment, + STATE(1296), 2, + sym__exclamation_operator, + sym_argument_part, + ACTIONS(2117), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25634] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2369), 1, + anon_sym_LBRACK, + ACTIONS(2372), 1, + anon_sym_LPAREN, + ACTIONS(2375), 1, + anon_sym_QMARK, + ACTIONS(2378), 1, + anon_sym_LT, + ACTIONS(2381), 1, + anon_sym_BANG, + ACTIONS(2384), 1, + anon_sym_DOT, + ACTIONS(2387), 1, + anon_sym_QMARK_DOT, + STATE(1205), 1, + sym_type_arguments, + STATE(1240), 1, + sym_selector, + STATE(1302), 1, + sym_arguments, + STATE(1304), 1, + sym_index_selector, + STATE(1305), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(746), 3, + sym_comment, + sym_documentation_comment, + aux_sym__assignable_selector_part_repeat1, + STATE(1296), 3, + sym__exclamation_operator, + sym_argument_part, + sym__assignable_selector, + ACTIONS(2133), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2119), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25728] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(747), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1943), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1945), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25796] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(1936), 1, + anon_sym_LPAREN, + ACTIONS(1941), 1, + anon_sym_GT, + ACTIONS(2390), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2913), 1, + sym__type, + STATE(748), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1932), 12, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(1934), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + [25892] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(749), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1947), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1949), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [25960] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(750), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1951), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1953), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [26028] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(751), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1955), 16, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1957), 28, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [26096] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(752), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1414), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1412), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [26229] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(753), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1408), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [26360] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(754), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1393), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [26491] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(755), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1385), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [26622] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2409), 1, + anon_sym_Function, + STATE(758), 1, + sym__function_builtin_identifier, + STATE(766), 1, + aux_sym__function_type_tails, + STATE(836), 1, + sym__function_type_tail, + STATE(756), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2405), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [26697] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2414), 1, + anon_sym_LPAREN, + ACTIONS(2418), 1, + anon_sym_QMARK, + ACTIONS(2422), 1, + anon_sym_LT, + STATE(804), 1, + sym_type_parameters, + STATE(806), 1, + sym_nullable_type, + STATE(826), 1, + sym_parameter_type_list, + STATE(757), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 8, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2411), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [26776] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2431), 1, + anon_sym_LPAREN, + ACTIONS(2434), 1, + anon_sym_QMARK, + ACTIONS(2437), 1, + anon_sym_LT, + STATE(789), 1, + sym_nullable_type, + STATE(804), 1, + sym_type_parameters, + STATE(826), 1, + sym_parameter_type_list, + STATE(758), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 8, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2429), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [26855] = 47, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(2442), 1, + anon_sym_RBRACE, + STATE(825), 1, + sym__metadata, + STATE(983), 1, + sym__required, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2665), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3177), 1, + sym__default_named_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(759), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [27000] = 38, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(760), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2444), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [27127] = 47, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(2446), 1, + anon_sym_RBRACE, + STATE(825), 1, + sym__metadata, + STATE(983), 1, + sym__required, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2665), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3177), 1, + sym__default_named_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(761), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [27272] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2454), 1, + anon_sym_LT, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(276), 1, + sym__assignment_operator, + STATE(887), 1, + aux_sym_cascade_section_repeat1, + STATE(912), 1, + sym__assignable_selector, + STATE(954), 1, + sym__cascade_assignment_section, + STATE(1033), 1, + aux_sym_cascade_section_repeat2, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(762), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1127), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [27375] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(763), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1420), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [27506] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(764), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1397), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [27637] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2409), 1, + anon_sym_Function, + STATE(758), 1, + sym__function_builtin_identifier, + STATE(766), 1, + aux_sym__function_type_tails, + STATE(836), 1, + sym__function_type_tail, + STATE(765), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2460), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [27712] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2468), 1, + anon_sym_Function, + STATE(758), 1, + sym__function_builtin_identifier, + STATE(836), 1, + sym__function_type_tail, + STATE(766), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2464), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [27785] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1403), 1, + anon_sym_QMARK, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + ACTIONS(2471), 1, + sym_equality_operator, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(767), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1401), 10, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [27910] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2454), 1, + anon_sym_LT, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(276), 1, + sym__assignment_operator, + STATE(762), 1, + aux_sym_cascade_section_repeat1, + STATE(908), 1, + sym__cascade_assignment_section, + STATE(912), 1, + sym__assignable_selector, + STATE(1081), 1, + aux_sym_cascade_section_repeat2, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(768), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1135), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [28013] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(769), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1412), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [28144] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(770), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1416), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [28275] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(771), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1424), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [28406] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(772), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1422), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1420), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [28539] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1430), 1, + anon_sym_QMARK, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(773), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1428), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [28662] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(774), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1397), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [28795] = 37, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + ACTIONS(2474), 1, + sym_equality_operator, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(775), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1403), 4, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1401), 7, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [28920] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(776), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1418), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1416), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29053] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(777), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1426), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1424), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29186] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(1432), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1435), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + STATE(778), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1430), 4, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1428), 8, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [29309] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(779), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1410), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1408), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29442] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(780), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1395), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1393), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29575] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(781), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1387), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1385), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29708] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2332), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2334), 1, + anon_sym_QMARK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2338), 1, + anon_sym_PIPE, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2342), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(324), 1, + sym_logical_and_operator, + STATE(325), 1, + sym_logical_or_operator, + STATE(916), 1, + sym_type_test, + STATE(917), 1, + sym_type_cast, + STATE(1346), 1, + sym__shift_operator, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1567), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1568), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1653), 1, + aux_sym__if_null_expression, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(2087), 1, + sym_is_operator, + STATE(2088), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(782), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1391), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1389), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [29841] = 40, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2393), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2395), 1, + anon_sym_QMARK, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2399), 1, + anon_sym_PIPE, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2403), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(311), 1, + sym_logical_and_operator, + STATE(312), 1, + sym_logical_or_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1596), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1597), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1678), 1, + aux_sym__if_null_expression, + STATE(1696), 1, + sym_type_test, + STATE(1698), 1, + sym_type_cast, + STATE(2106), 1, + sym_is_operator, + STATE(2108), 1, + sym_as_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(783), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1389), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [29972] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(784), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1967), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1969), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30038] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(785), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1925), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1927), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30104] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(393), 1, + sym_multiplicative_operator, + STATE(803), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(786), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2477), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30180] = 46, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(825), 1, + sym__metadata, + STATE(983), 1, + sym__required, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2665), 1, + sym_formal_parameter, + STATE(2726), 1, + sym__default_named_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(787), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [30322] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2487), 1, + anon_sym_QMARK, + ACTIONS(2490), 1, + anon_sym_LT, + STATE(824), 1, + sym_type_arguments, + STATE(860), 1, + sym_nullable_type, + STATE(788), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 8, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2485), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30396] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2497), 1, + anon_sym_LPAREN, + ACTIONS(2500), 1, + anon_sym_QMARK, + STATE(819), 1, + sym_parameter_type_list, + STATE(866), 1, + sym_nullable_type, + STATE(789), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2495), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30470] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(790), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1995), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1997), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30536] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(791), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1999), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2001), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30602] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(792), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2003), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2005), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30668] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(793), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2007), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2009), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30734] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(794), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1901), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1903), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30800] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(795), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2011), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2013), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30866] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(796), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2015), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2017), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30932] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(797), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1905), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1907), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [30998] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2507), 1, + anon_sym_LPAREN, + ACTIONS(2510), 1, + anon_sym_QMARK, + STATE(816), 1, + sym_parameter_type_list, + STATE(872), 1, + sym_nullable_type, + STATE(798), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2505), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31072] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(799), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1921), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1923), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31138] = 46, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(973), 1, + sym__required, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1823), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2611), 1, + sym__final_const_var_or_type, + STATE(2633), 1, + sym_formal_parameter, + STATE(2637), 1, + sym__simple_formal_parameter, + STATE(2907), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3120), 1, + sym_typed_identifier, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(800), 2, + sym_comment, + sym_documentation_comment, + STATE(2636), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [31280] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(334), 1, + sym_shift_operator, + STATE(802), 1, + aux_sym_shift_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(801), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2515), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31352] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(334), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(802), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1408), 27, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31426] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(393), 1, + sym_multiplicative_operator, + STATE(809), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(803), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2527), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2525), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31498] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2497), 1, + anon_sym_LPAREN, + ACTIONS(2500), 1, + anon_sym_QMARK, + STATE(798), 1, + sym_nullable_type, + STATE(819), 1, + sym_parameter_type_list, + STATE(804), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2495), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31572] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(939), 1, + sym_cascade_section, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + STATE(2502), 1, + aux_sym__expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(2170), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(805), 2, + sym_comment, + sym_documentation_comment, + [31708] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2532), 1, + anon_sym_LPAREN, + ACTIONS(2536), 1, + anon_sym_QMARK, + STATE(819), 1, + sym_parameter_type_list, + STATE(866), 1, + sym_nullable_type, + STATE(806), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2529), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31782] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1293), 1, + anon_sym_is, + ACTIONS(1295), 1, + anon_sym_as, + ACTIONS(1300), 1, + anon_sym_AMP_AMP, + ACTIONS(1302), 1, + anon_sym_PIPE_PIPE, + ACTIONS(2144), 1, + anon_sym_QMARK_QMARK, + ACTIONS(2146), 1, + anon_sym_QMARK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2150), 1, + anon_sym_PIPE, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2154), 1, + anon_sym_AMP, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(339), 1, + sym_logical_and_operator, + STATE(340), 1, + sym_logical_or_operator, + STATE(373), 1, + sym_relational_operator, + STATE(939), 1, + sym_cascade_section, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1376), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1395), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1455), 1, + aux_sym__if_null_expression, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1480), 1, + sym_type_cast, + STATE(1500), 1, + sym_type_test, + STATE(2102), 1, + sym_as_operator, + STATE(2126), 1, + sym_is_operator, + STATE(2504), 1, + aux_sym__expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(2241), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(807), 2, + sym_comment, + sym_documentation_comment, + [31918] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(808), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1943), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1945), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [31984] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2550), 1, + anon_sym_SLASH, + STATE(393), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(2547), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + STATE(809), 3, + sym_comment, + sym_documentation_comment, + aux_sym_multiplicative_expression_repeat1, + ACTIONS(2545), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2543), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32058] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(810), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1947), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1949), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32124] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(811), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1951), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1953), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32190] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(812), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1955), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1957), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32256] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(813), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1959), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1961), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32322] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(814), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1963), 12, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1965), 30, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32388] = 46, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(825), 1, + sym__metadata, + STATE(983), 1, + sym__required, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2665), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3177), 1, + sym__default_named_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(815), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [32530] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2555), 1, + anon_sym_QMARK, + STATE(878), 1, + sym_nullable_type, + STATE(816), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2553), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32599] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(335), 1, + sym_additive_operator, + STATE(832), 1, + aux_sym_additive_expression_repeat1, + STATE(817), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2560), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32668] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(336), 1, + sym_logical_and_operator, + STATE(818), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1385), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_PIPE_PIPE, + [32737] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2510), 1, + anon_sym_QMARK, + STATE(872), 1, + sym_nullable_type, + STATE(819), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2505), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32806] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1330), 1, + sym_increment_operator, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(820), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 9, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1322), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32879] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 1, + sym_cascade_section, + ACTIONS(2571), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(821), 3, + sym_comment, + sym_documentation_comment, + aux_sym__expression_repeat1, + ACTIONS(2569), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2567), 27, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [32948] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2576), 1, + anon_sym_QMARK, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(874), 1, + sym_nullable_type, + STATE(822), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2574), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33019] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2583), 1, + anon_sym_DOT, + STATE(858), 1, + sym__type_dot_identifier, + STATE(823), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(2044), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33088] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2588), 1, + anon_sym_QMARK, + STATE(899), 1, + sym_nullable_type, + STATE(824), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2586), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33157] = 45, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(973), 1, + sym__required, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1823), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2611), 1, + sym__final_const_var_or_type, + STATE(2633), 1, + sym_formal_parameter, + STATE(2637), 1, + sym__simple_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(825), 2, + sym_comment, + sym_documentation_comment, + STATE(2636), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [33296] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2500), 1, + anon_sym_QMARK, + STATE(866), 1, + sym_nullable_type, + STATE(826), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2495), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33365] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(1133), 1, + anon_sym_async, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2454), 1, + anon_sym_LT, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(292), 1, + sym__assignment_operator, + STATE(887), 1, + aux_sym_cascade_section_repeat1, + STATE(912), 1, + sym__assignable_selector, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(1222), 1, + aux_sym_cascade_section_repeat2, + STATE(1990), 1, + sym__cascade_assignment_section, + STATE(3318), 1, + sym_type_arguments, + STATE(827), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1127), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [33468] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(821), 1, + aux_sym__expression_repeat1, + STATE(939), 1, + sym_cascade_section, + ACTIONS(2597), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(828), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2595), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2593), 27, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33539] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(1137), 1, + anon_sym_async, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2454), 1, + anon_sym_LT, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(292), 1, + sym__assignment_operator, + STATE(827), 1, + aux_sym_cascade_section_repeat1, + STATE(912), 1, + sym__assignable_selector, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(1220), 1, + aux_sym_cascade_section_repeat2, + STATE(1988), 1, + sym__cascade_assignment_section, + STATE(3318), 1, + sym_type_arguments, + STATE(829), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1135), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [33642] = 45, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(2600), 1, + anon_sym_RBRACK, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2728), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3196), 1, + sym__default_formal_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(830), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [33781] = 45, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(2602), 1, + anon_sym_RBRACK, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2728), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3196), 1, + sym__default_formal_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(831), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [33920] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(335), 1, + sym_additive_operator, + STATE(832), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1393), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [33989] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(337), 1, + sym_logical_or_operator, + STATE(833), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1389), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + [34058] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(337), 1, + sym_logical_or_operator, + STATE(833), 1, + aux_sym_logical_or_expression_repeat1, + STATE(834), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2610), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34127] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(336), 1, + sym_logical_and_operator, + STATE(818), 1, + aux_sym_logical_and_expression_repeat1, + STATE(835), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2614), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34196] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(836), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2618), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34260] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2624), 1, + anon_sym_EQ, + STATE(837), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2626), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2622), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34326] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2630), 1, + anon_sym_EQ, + STATE(838), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2632), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2628), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34392] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(921), 1, + sym_arguments, + STATE(839), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2636), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2634), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34460] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(848), 1, + aux_sym__if_null_expression, + STATE(840), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2638), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34526] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(849), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(841), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2642), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34592] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(850), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(842), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2646), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34658] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(851), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(843), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2650), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34724] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(844), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1677), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34788] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(845), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1655), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34852] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1713), 1, + sym_increment_operator, + STATE(846), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34918] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1696), 1, + sym_increment_operator, + STATE(847), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1698), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1692), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [34984] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2656), 1, + anon_sym_QMARK_QMARK, + STATE(848), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2654), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35050] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2661), 1, + anon_sym_PIPE, + STATE(849), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1412), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35116] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2664), 1, + anon_sym_CARET, + STATE(850), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1416), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35182] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2667), 1, + anon_sym_AMP, + STATE(851), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1424), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35248] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(852), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1663), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35312] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(853), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35376] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1685), 1, + sym_increment_operator, + STATE(854), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35442] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(855), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1707), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35506] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(856), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2670), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35570] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(857), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2674), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35634] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(858), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2678), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35698] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(859), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2682), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35762] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(860), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2586), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35826] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(861), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2686), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35890] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(862), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2690), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [35954] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(932), 1, + sym_arguments, + STATE(863), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36022] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(864), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2694), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36086] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(865), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2698), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36150] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(866), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2505), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36214] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(867), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2702), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36278] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(868), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2574), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36344] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2576), 1, + anon_sym_QMARK, + STATE(931), 1, + sym_nullable_type, + STATE(869), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 9, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2574), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36412] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(870), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2708), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2706), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36476] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(871), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2710), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36540] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(872), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2553), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36604] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(873), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2714), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36668] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2722), 1, + anon_sym_Function, + STATE(874), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2718), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36734] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(875), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2726), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2724), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36798] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2728), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3196), 1, + sym__default_formal_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(876), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [36934] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(877), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2728), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [36998] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(878), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2732), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37062] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(879), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2736), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37126] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(880), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2740), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37190] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(881), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2744), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37254] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(882), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2748), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37318] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(883), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2752), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37382] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(884), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2756), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37446] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(885), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2760), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37510] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1004), 1, + anon_sym_EQ, + STATE(886), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1006), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37576] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1445), 1, + anon_sym_LT, + ACTIONS(2764), 1, + anon_sym_LPAREN, + STATE(1129), 1, + sym_argument_part, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(887), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat1, + ACTIONS(1443), 5, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1438), 29, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [37650] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2767), 1, + anon_sym_Function, + STATE(890), 1, + aux_sym__function_type_tails, + STATE(892), 1, + sym__function_builtin_identifier, + STATE(1062), 1, + sym__function_type_tail, + STATE(888), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2405), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37722] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2767), 1, + anon_sym_Function, + STATE(890), 1, + aux_sym__function_type_tails, + STATE(892), 1, + sym__function_builtin_identifier, + STATE(1062), 1, + sym__function_type_tail, + STATE(889), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2460), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37794] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2769), 1, + anon_sym_Function, + STATE(892), 1, + sym__function_builtin_identifier, + STATE(1062), 1, + sym__function_type_tail, + STATE(890), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2464), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37864] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2772), 1, + anon_sym_LPAREN, + ACTIONS(2776), 1, + anon_sym_QMARK, + ACTIONS(2780), 1, + anon_sym_LT, + STATE(965), 1, + sym_type_parameters, + STATE(966), 1, + sym_nullable_type, + STATE(1023), 1, + sym_parameter_type_list, + STATE(891), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 10, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2411), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [37940] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2784), 1, + anon_sym_LPAREN, + ACTIONS(2787), 1, + anon_sym_QMARK, + ACTIONS(2790), 1, + anon_sym_LT, + STATE(965), 1, + sym_type_parameters, + STATE(967), 1, + sym_nullable_type, + STATE(1023), 1, + sym_parameter_type_list, + STATE(892), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 10, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2429), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38016] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2799), 1, + anon_sym_LT, + ACTIONS(2803), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(2793), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(893), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2796), 3, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1328), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1330), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38090] = 44, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2728), 1, + sym_formal_parameter, + STATE(2729), 1, + sym__default_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(894), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [38226] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(895), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1703), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1705), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38290] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(896), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2808), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38354] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2814), 1, + anon_sym_EQ, + STATE(897), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2816), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2812), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38420] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(898), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2818), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38484] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(899), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2822), 30, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38548] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(900), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2828), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2826), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38611] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(901), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1681), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38674] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(902), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2832), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2830), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38737] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(903), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2479), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2477), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38800] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(904), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2836), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2834), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38863] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(905), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2838), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38926] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(906), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1731), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [38989] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(907), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2844), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2842), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39052] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(908), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1133), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1127), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39115] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(909), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2033), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2019), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39178] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(910), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2848), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2846), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39241] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(911), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1889), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39304] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2454), 1, + anon_sym_LT, + STATE(953), 1, + aux_sym_cascade_section_repeat1, + STATE(1129), 1, + sym_argument_part, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(912), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1380), 5, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1375), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [39379] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(913), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2852), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2850), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39442] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(914), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2856), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2854), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39505] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(915), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2860), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2858), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39568] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(916), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2864), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2862), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39631] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(917), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2868), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2866), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39694] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(918), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2872), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2870), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39757] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(919), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1707), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39820] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(920), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2876), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2874), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39883] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(921), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2880), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2878), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [39946] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(922), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2884), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2882), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40009] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(923), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2888), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2886), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40072] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(924), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2892), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2890), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40135] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(925), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2896), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2894), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40198] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(926), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2900), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2898), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40261] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(927), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1696), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40324] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(928), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2904), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2902), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40387] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(929), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2117), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2115), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40450] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(930), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1322), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40513] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(931), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2718), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40576] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(932), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1853), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40639] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(933), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2908), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2906), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40702] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(934), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2912), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2910), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40765] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(935), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2916), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2914), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40828] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(936), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1663), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40891] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(937), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1053), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1051), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [40954] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(938), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1893), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41017] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2920), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2918), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41080] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(940), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2924), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2922), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41143] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(941), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1397), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41206] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(942), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2928), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2926), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41269] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(943), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1271), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41332] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(944), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2932), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2930), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41395] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(945), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2936), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2934), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41458] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(946), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2940), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2938), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41521] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(947), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2944), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2942), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41584] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(399), 1, + sym_multiplicative_operator, + STATE(963), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(948), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2477), 21, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41657] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(949), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2948), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2946), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41720] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(950), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2952), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2950), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41783] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(367), 1, + sym_shift_operator, + STATE(957), 1, + aux_sym_shift_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(951), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2515), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41852] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(952), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2956), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2954), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [41915] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2450), 1, + anon_sym_LPAREN, + ACTIONS(2454), 1, + anon_sym_LT, + STATE(887), 1, + aux_sym_cascade_section_repeat1, + STATE(1129), 1, + sym_argument_part, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(953), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1370), 5, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1365), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [41990] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(954), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1157), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1155), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42053] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2958), 1, + anon_sym_LBRACK, + ACTIONS(2961), 1, + anon_sym_QMARK, + ACTIONS(2964), 1, + anon_sym_DOT, + ACTIONS(2967), 1, + anon_sym_QMARK_DOT, + STATE(912), 1, + sym__assignable_selector, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + ACTIONS(1309), 2, + anon_sym_EQ, + anon_sym_async, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(955), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat2, + ACTIONS(1304), 27, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [42132] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(956), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2972), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2970), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42195] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(367), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(957), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1408), 22, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42266] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2550), 1, + anon_sym_SLASH, + STATE(399), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(2547), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + STATE(958), 3, + sym_comment, + sym_documentation_comment, + aux_sym_multiplicative_expression_repeat1, + ACTIONS(2545), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2543), 21, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42337] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(959), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2976), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2974), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42400] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2978), 1, + anon_sym_QMARK, + ACTIONS(2981), 1, + anon_sym_LT, + STATE(1022), 1, + sym_type_arguments, + STATE(1071), 1, + sym_nullable_type, + STATE(960), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 10, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2485), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42471] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(961), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2986), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2984), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42534] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(962), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2990), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2988), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42597] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(399), 1, + sym_multiplicative_operator, + STATE(958), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(963), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2527), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2525), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42666] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(964), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2545), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2543), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42729] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2992), 1, + anon_sym_LPAREN, + ACTIONS(2995), 1, + anon_sym_QMARK, + STATE(968), 1, + sym_nullable_type, + STATE(1024), 1, + sym_parameter_type_list, + STATE(965), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2495), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42800] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2998), 1, + anon_sym_LPAREN, + ACTIONS(3002), 1, + anon_sym_QMARK, + STATE(1024), 1, + sym_parameter_type_list, + STATE(1080), 1, + sym_nullable_type, + STATE(966), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2529), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42871] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2992), 1, + anon_sym_LPAREN, + ACTIONS(2995), 1, + anon_sym_QMARK, + STATE(1024), 1, + sym_parameter_type_list, + STATE(1080), 1, + sym_nullable_type, + STATE(967), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2495), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [42942] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3006), 1, + anon_sym_LPAREN, + ACTIONS(3009), 1, + anon_sym_QMARK, + STATE(1008), 1, + sym_parameter_type_list, + STATE(1072), 1, + sym_nullable_type, + STATE(968), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2505), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43013] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3012), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(969), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1711), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(3015), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1713), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43080] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3018), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(970), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(3021), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1696), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43147] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3024), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(971), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1683), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(3027), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1685), 27, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43214] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(972), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3032), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3030), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43277] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2648), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(973), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [43410] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(974), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3036), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3034), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43473] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(975), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3040), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3038), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43536] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(976), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3044), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3042), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43599] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(977), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3048), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3046), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43662] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(978), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3052), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3050), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43725] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(979), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3056), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3054), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43788] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(980), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2626), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2622), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43851] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(981), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3060), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3058), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43914] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(982), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3064), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3062), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [43977] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2633), 1, + sym_formal_parameter, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(983), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [44110] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(984), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3068), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3066), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44173] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(985), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3072), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3070), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44236] = 43, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1059), 1, + sym__metadata, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1819), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2478), 1, + sym__simple_formal_parameter, + STATE(2493), 1, + sym__normal_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2604), 1, + sym__final_const_var_or_type, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3261), 1, + sym_formal_parameter, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(986), 2, + sym_comment, + sym_documentation_comment, + STATE(2555), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [44369] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(987), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2632), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2628), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44432] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(988), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3076), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3074), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44495] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(989), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3080), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3078), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44558] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(990), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(997), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(999), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44621] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(2796), 1, + anon_sym_QMARK, + ACTIONS(2799), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1322), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(1332), 2, + anon_sym_BANG, + anon_sym_QMARK_DOT, + STATE(991), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1328), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1330), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44696] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(992), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1667), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44759] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(993), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3084), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3082), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44822] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(994), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3088), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3086), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44885] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(995), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3092), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3090), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [44948] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(996), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3096), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3094), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45011] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(997), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3100), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3098), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45074] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(998), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3104), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3102), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45137] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(999), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1677), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45200] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1000), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1655), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45263] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1001), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3108), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3106), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45326] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1002), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3110), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45389] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1003), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1006), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45452] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1004), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2816), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2812), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45515] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1005), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3116), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3114), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45578] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1006), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3120), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3118), 29, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45641] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + ACTIONS(3122), 1, + anon_sym_QMARK, + STATE(1087), 1, + sym_nullable_type, + STATE(1007), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2574), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45709] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3125), 1, + anon_sym_QMARK, + STATE(1046), 1, + sym_nullable_type, + STATE(1008), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2553), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45775] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3128), 1, + anon_sym_DOT, + STATE(1065), 1, + sym__type_dot_identifier, + STATE(1009), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2044), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45841] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(368), 1, + sym_additive_operator, + STATE(1019), 1, + aux_sym_additive_expression_repeat1, + STATE(1010), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2560), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45907] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(821), 1, + aux_sym__expression_repeat1, + STATE(939), 1, + sym_cascade_section, + ACTIONS(1507), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(1011), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2595), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2593), 24, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [45975] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3131), 1, + anon_sym_LPAREN, + ACTIONS(3134), 1, + anon_sym_LT, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2299), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(1012), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2900), 9, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2898), 23, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46049] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1153), 1, + sym_cascade_section, + ACTIONS(3137), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(1013), 3, + sym_comment, + sym_documentation_comment, + aux_sym__expression_repeat1, + ACTIONS(2569), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2567), 22, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46115] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(370), 1, + sym_logical_or_operator, + STATE(1014), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1389), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + [46181] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1330), 1, + sym_increment_operator, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(1341), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(1015), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 11, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1322), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46251] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1681), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3027), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1016), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1683), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1685), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46319] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(369), 1, + sym_logical_and_operator, + STATE(1017), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1385), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_PIPE_PIPE, + [46385] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1013), 1, + aux_sym__expression_repeat1, + STATE(1153), 1, + sym_cascade_section, + ACTIONS(3140), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(1018), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2595), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2593), 22, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46453] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(368), 1, + sym_additive_operator, + STATE(1019), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1393), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46519] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(370), 1, + sym_logical_or_operator, + STATE(1014), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1020), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2610), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46585] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(369), 1, + sym_logical_and_operator, + STATE(1017), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1021), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2614), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46651] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3143), 1, + anon_sym_QMARK, + STATE(1076), 1, + sym_nullable_type, + STATE(1022), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2586), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46717] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2995), 1, + anon_sym_QMARK, + STATE(1080), 1, + sym_nullable_type, + STATE(1023), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2495), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46783] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3009), 1, + anon_sym_QMARK, + STATE(1072), 1, + sym_nullable_type, + STATE(1024), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2505), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46849] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1681), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3015), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1025), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1711), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1713), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46917] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1692), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3021), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1026), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1698), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1694), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1696), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [46985] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3146), 1, + anon_sym_PIPE, + STATE(1027), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1412), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47048] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1028), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2808), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47109] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1004), 1, + anon_sym_EQ, + STATE(1029), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1006), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47172] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1030), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2726), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2724), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47233] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1031), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2728), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47294] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1032), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2818), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47355] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(276), 1, + sym__assignment_operator, + STATE(912), 1, + sym__assignable_selector, + STATE(955), 1, + aux_sym_cascade_section_repeat2, + STATE(976), 1, + sym__cascade_assignment_section, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1033), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1155), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [47440] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1034), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2694), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47501] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3153), 1, + anon_sym_AT, + ACTIONS(3156), 1, + anon_sym_export, + ACTIONS(3159), 1, + anon_sym_import, + STATE(1484), 1, + aux_sym__metadata_repeat1, + STATE(1570), 1, + sym_import_or_export, + STATE(1588), 1, + sym_annotation, + STATE(1595), 1, + sym_import_specification, + STATE(1864), 1, + sym__export, + STATE(1866), 1, + sym__import, + STATE(2617), 1, + sym__metadata, + STATE(1580), 2, + sym_library_import, + sym_library_export, + ACTIONS(3149), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + sym_part_of_builtin, + STATE(1035), 3, + sym_comment, + sym_documentation_comment, + aux_sym_program_repeat1, + ACTIONS(3151), 21, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [47584] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1713), 1, + sym_increment_operator, + STATE(1036), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1681), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47647] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1696), 1, + sym_increment_operator, + STATE(1037), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1698), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1692), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47710] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1685), 1, + sym_increment_operator, + STATE(1038), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1681), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47773] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(1148), 1, + sym_arguments, + STATE(1039), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1681), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47838] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2814), 1, + anon_sym_EQ, + STATE(1040), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2816), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2812), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47901] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1041), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1677), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [47962] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1042), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1655), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48023] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3162), 1, + anon_sym_QMARK_QMARK, + STATE(1043), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2654), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48086] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1044), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1663), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48147] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1045), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1667), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48208] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1046), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2732), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48269] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1047), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 13, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1707), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48330] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1048), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2736), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48391] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1049), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2740), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48452] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1341), 1, + anon_sym_DOT, + ACTIONS(2796), 1, + anon_sym_QMARK, + ACTIONS(2799), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1322), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(1332), 2, + anon_sym_BANG, + anon_sym_QMARK_DOT, + STATE(1050), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1328), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1330), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48525] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1051), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2744), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48586] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2799), 1, + anon_sym_LT, + ACTIONS(2803), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(2793), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(1052), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2796), 3, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1328), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1330), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48657] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1054), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1053), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2646), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48720] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3165), 1, + anon_sym_CARET, + STATE(1054), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1416), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48783] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1055), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2710), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48844] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1056), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2748), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48905] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1057), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2752), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [48966] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(1186), 1, + sym_arguments, + STATE(1058), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2636), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2634), 23, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49031] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2271), 1, + sym_identifier, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1729), 1, + sym__metadata, + STATE(1816), 1, + sym__type_not_function, + STATE(1823), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2487), 1, + sym__simple_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2611), 1, + sym__final_const_var_or_type, + STATE(2942), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(1059), 2, + sym_comment, + sym_documentation_comment, + STATE(2474), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [49158] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1060), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2670), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49219] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1043), 1, + aux_sym__if_null_expression, + STATE(1061), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2638), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49282] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1062), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2618), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49343] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1063), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2756), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49404] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1064), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2674), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49465] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1065), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2678), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49526] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1066), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2760), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49587] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1067), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2682), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49648] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1027), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1068), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2642), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49711] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2624), 1, + anon_sym_EQ, + STATE(1069), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2626), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2622), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49774] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(2277), 1, + sym_const_builtin, + STATE(524), 1, + sym_lambda_expression, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1729), 1, + sym__metadata, + STATE(1750), 1, + sym_inferred_type, + STATE(1813), 1, + sym_final_builtin, + STATE(1816), 1, + sym__type_not_function, + STATE(1820), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2414), 1, + sym_function_signature, + STATE(2585), 1, + sym__type, + STATE(2675), 1, + sym__declared_identifier, + STATE(2948), 1, + sym__var_or_type, + STATE(3328), 1, + sym__final_const_var_or_type, + STATE(1070), 2, + sym_comment, + sym_documentation_comment, + STATE(2494), 2, + sym__get, + sym__set, + STATE(3054), 2, + sym_pattern_variable_declaration, + sym_initialized_variable_definition, + [49901] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1071), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2586), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [49962] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1072), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2553), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50023] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2630), 1, + anon_sym_EQ, + STATE(1073), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2632), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2628), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50086] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1074), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2686), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50147] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1075), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2690), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50208] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1076), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2822), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50269] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1077), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2698), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50330] = 41, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3168), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1729), 1, + sym__metadata, + STATE(1816), 1, + sym__type_not_function, + STATE(1823), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2487), 1, + sym__simple_formal_parameter, + STATE(2501), 1, + sym__declared_identifier, + STATE(2565), 1, + sym__type, + STATE(2611), 1, + sym__final_const_var_or_type, + STATE(2948), 1, + sym__var_or_type, + STATE(3352), 1, + sym_this, + STATE(3400), 1, + sym_super, + STATE(1078), 2, + sym_comment, + sym_documentation_comment, + STATE(2474), 3, + sym__function_formal_parameter, + sym_super_formal_parameter, + sym_constructor_param, + [50457] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1089), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1079), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2650), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50520] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1080), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2505), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50581] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(276), 1, + sym__assignment_operator, + STATE(912), 1, + sym__assignable_selector, + STATE(954), 1, + sym__cascade_assignment_section, + STATE(955), 1, + aux_sym_cascade_section_repeat2, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1081), 2, + sym_comment, + sym_documentation_comment, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + ACTIONS(1127), 11, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [50666] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1082), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2714), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50727] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1083), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2702), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50788] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(1084), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2574), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50851] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1085), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3074), 14, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + anon_sym_QMARK_DOT, + ACTIONS(3076), 23, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_QMARK, + sym_minus_operator, + anon_sym_await, + anon_sym_DOT, + anon_sym_switch, + sym_void_type, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [50912] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3122), 1, + anon_sym_QMARK, + STATE(1144), 1, + sym_nullable_type, + STATE(1086), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 11, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2574), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [50977] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2722), 1, + anon_sym_Function, + STATE(1087), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2718), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51040] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1088), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2708), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2706), 25, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51101] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3170), 1, + anon_sym_AMP, + STATE(1089), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 11, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1424), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51164] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1090), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1655), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51224] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(386), 1, + sym_multiplicative_operator, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1091), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2477), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51294] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1092), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3052), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3050), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51354] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1093), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3088), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3086), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51414] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1094), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3092), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3090), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51474] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1095), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3096), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3094), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51534] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1096), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(997), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(999), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51594] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1097), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3104), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3102), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51654] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1098), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3080), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3078), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51714] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1099), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2908), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2906), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51774] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1100), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2479), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2477), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51834] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1101), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2844), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2842), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51894] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1102), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2033), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2019), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [51954] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1103), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2848), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2846), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52014] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1104), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1889), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52074] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1105), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3084), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3082), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52134] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1106), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2852), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2850), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52194] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1107), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2856), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2854), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52254] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1108), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1889), 11, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_SEMI, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(1891), 25, + anon_sym_QMARK, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [52314] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1109), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2864), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2862), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52374] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1110), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2868), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2866), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52434] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1111), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2956), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2954), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52494] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1112), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2904), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2902), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52554] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1113), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(919), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(914), 23, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_default, + anon_sym_case, + sym_rethrow_builtin, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [52614] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1114), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2117), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2115), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52674] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1115), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1893), 11, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_SEMI, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(1895), 25, + anon_sym_QMARK, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [52734] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1116), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1157), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1155), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52794] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1117), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1053), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1051), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52854] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1118), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1893), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52914] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1119), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3100), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3098), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [52974] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1120), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3044), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3042), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53034] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1121), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2932), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2930), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53094] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1122), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2948), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2946), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53154] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1123), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3068), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3066), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53214] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1124), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3072), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3070), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53274] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1125), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1841), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1839), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [53334] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1126), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2545), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2543), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53394] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1127), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2832), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2830), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53454] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1128), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2836), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2834), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53514] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1129), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1845), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1843), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [53574] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1130), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3056), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3054), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53634] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1131), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3076), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3074), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53694] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1132), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2872), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2870), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53754] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1133), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2876), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2874), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53814] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1134), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1322), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53874] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1135), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2828), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2826), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [53934] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1136), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1849), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1847), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [53994] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1137), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1271), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54054] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1330), 1, + sym_increment_operator, + ACTIONS(1334), 1, + anon_sym_LT, + ACTIONS(2078), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(1138), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 8, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1322), 24, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54122] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1139), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2900), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2898), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54182] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1140), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1696), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54242] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1141), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1731), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54302] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1142), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1677), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [54362] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1143), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1655), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [54422] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1144), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2718), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54482] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1145), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1397), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54542] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1146), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1663), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [54602] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1147), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1667), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [54662] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1148), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1853), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54722] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1149), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3108), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3106), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54782] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1150), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3110), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54842] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1151), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2990), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2988), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54902] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1152), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2838), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [54962] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1153), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2920), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2918), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55022] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1154), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3120), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3118), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55082] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1155), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1133), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1127), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55142] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1156), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1731), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [55202] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1157), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2924), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2922), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55262] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1158), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2940), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2938), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55322] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1159), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1889), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [55382] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1160), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1893), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [55442] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1681), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3015), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1161), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1711), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1713), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55508] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1692), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3021), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1162), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1698), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1694), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1696), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55574] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1681), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + ACTIONS(3027), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1163), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 3, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1683), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1685), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55640] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1164), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2626), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2622), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55700] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1165), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2632), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2628), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55760] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1166), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1703), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1705), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55820] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1167), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1006), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55880] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1168), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2816), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2812), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [55940] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1169), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1677), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56000] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1170), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3116), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3114), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56060] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3012), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(1171), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3015), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1711), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1713), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56124] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3018), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(1172), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3021), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1694), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1696), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56188] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1173), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1663), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56248] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1174), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1667), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56308] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3024), 2, + anon_sym_LBRACK, + anon_sym_LPAREN, + STATE(1175), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3027), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1683), 7, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1685), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56372] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1176), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1707), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56432] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1177), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1853), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [56492] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1178), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2860), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2858), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56552] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1179), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3052), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + ACTIONS(3050), 28, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56612] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1180), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2976), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2974), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56672] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1181), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2986), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2984), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56732] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1182), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2884), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2882), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56792] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1183), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2912), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2910), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56852] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1184), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2928), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2926), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [56912] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1185), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1707), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [56972] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1186), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2880), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2878), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57032] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1187), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2888), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2886), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57092] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1188), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2892), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2890), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57152] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1189), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2896), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2894), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57212] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1190), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2916), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2914), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57272] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1191), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2936), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2934), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57332] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1192), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2944), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2942), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57392] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1193), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2952), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2950), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57452] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1194), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2972), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2970), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57512] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(386), 1, + sym_multiplicative_operator, + STATE(1202), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1195), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2527), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2525), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57582] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1196), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1787), 6, + anon_sym_EQ, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1785), 30, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [57642] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1197), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3032), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3030), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57702] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1198), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3036), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3034), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57762] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1199), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3040), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3038), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57822] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1200), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3048), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3046), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57882] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1201), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3060), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3058), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [57942] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2550), 1, + anon_sym_SLASH, + STATE(386), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(2547), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + STATE(1202), 3, + sym_comment, + sym_documentation_comment, + aux_sym_multiplicative_expression_repeat1, + ACTIONS(2545), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2543), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58010] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1203), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3064), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3062), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58070] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1204), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 12, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1681), 24, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58130] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + STATE(1232), 1, + sym_arguments, + STATE(1205), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1681), 25, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58193] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1206), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1677), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58252] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1207), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1655), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58311] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1208), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1663), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58370] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1209), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1667), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58429] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1713), 1, + sym_increment_operator, + STATE(1210), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1681), 25, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58490] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2814), 1, + anon_sym_EQ, + ACTIONS(3176), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1211), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3173), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2816), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2812), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [58555] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1685), 1, + sym_increment_operator, + STATE(1212), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1681), 25, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58616] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(280), 1, + sym__assignment_operator, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(1214), 1, + aux_sym_cascade_section_repeat1, + STATE(1385), 1, + aux_sym_cascade_section_repeat2, + STATE(1592), 1, + sym__assignable_selector, + STATE(1988), 1, + sym__cascade_assignment_section, + STATE(3318), 1, + sym_type_arguments, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1213), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1137), 4, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1135), 5, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [58699] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(280), 1, + sym__assignment_operator, + STATE(887), 1, + aux_sym_cascade_section_repeat1, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1129), 1, + sym_argument_part, + STATE(1142), 1, + sym_index_selector, + STATE(1156), 1, + sym_arguments, + STATE(1413), 1, + aux_sym_cascade_section_repeat2, + STATE(1592), 1, + sym__assignable_selector, + STATE(1990), 1, + sym__cascade_assignment_section, + STATE(3318), 1, + sym_type_arguments, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1214), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1133), 4, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1127), 5, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [58782] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + STATE(1233), 1, + sym_arguments, + STATE(1215), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2636), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2634), 25, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58845] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2624), 1, + anon_sym_EQ, + ACTIONS(3182), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1216), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3179), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2626), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2622), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [58910] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1696), 1, + sym_increment_operator, + STATE(1217), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1698), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1692), 25, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [58971] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1004), 1, + anon_sym_EQ, + ACTIONS(3188), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1218), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3185), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1008), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1006), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [59036] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3193), 1, + anon_sym_LPAREN, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3199), 1, + anon_sym_DOT, + STATE(1393), 1, + sym_arguments, + STATE(3112), 1, + sym_type_arguments, + ACTIONS(3195), 2, + anon_sym_QMARK, + anon_sym_AT, + STATE(1219), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3191), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [59105] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(1133), 1, + anon_sym_async, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(292), 1, + sym__assignment_operator, + STATE(912), 1, + sym__assignable_selector, + STATE(955), 1, + aux_sym_cascade_section_repeat2, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1990), 1, + sym__cascade_assignment_section, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1220), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1127), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [59190] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2630), 1, + anon_sym_EQ, + ACTIONS(3204), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1221), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3201), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2632), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2628), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [59255] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1129), 1, + anon_sym_EQ, + ACTIONS(1157), 1, + anon_sym_async, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(2452), 1, + anon_sym_QMARK, + ACTIONS(2456), 1, + anon_sym_DOT, + ACTIONS(2458), 1, + anon_sym_QMARK_DOT, + STATE(292), 1, + sym__assignment_operator, + STATE(912), 1, + sym__assignable_selector, + STATE(955), 1, + aux_sym_cascade_section_repeat2, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1991), 1, + sym__cascade_assignment_section, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1222), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1155), 8, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + ACTIONS(1131), 13, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [59340] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1223), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + sym__additive_operator, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1707), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + sym_increment_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59399] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1332), 1, + anon_sym_BANG, + ACTIONS(2078), 1, + anon_sym_DOT, + ACTIONS(2796), 1, + anon_sym_QMARK, + ACTIONS(2799), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(1224), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 3, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_DOT, + ACTIONS(1328), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1330), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59470] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(921), 1, + sym_arguments, + ACTIONS(3210), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1225), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3207), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2636), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2634), 16, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [59537] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3213), 1, + anon_sym_DOT, + STATE(1226), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_QMARK_DOT, + ACTIONS(1322), 24, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59597] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1227), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2818), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59655] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1228), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1709), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1707), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59713] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1229), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2876), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2874), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59771] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1230), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3072), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3070), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59829] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1231), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1332), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1322), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59887] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1232), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1855), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1853), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [59945] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1233), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2880), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2878), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60003] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1234), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1895), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1893), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60061] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1235), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2908), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2906), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60119] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1236), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2828), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2826), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60177] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1237), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2896), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2894), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60235] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(389), 1, + sym_multiplicative_operator, + STATE(1249), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1238), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2477), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60303] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1239), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3048), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3046), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60361] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1240), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3120), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3118), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60419] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1241), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3060), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3058), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60477] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1242), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3064), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3062), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60535] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1243), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2808), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60593] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3218), 1, + anon_sym_QMARK, + ACTIONS(3222), 1, + anon_sym_LT, + STATE(1315), 1, + sym_type_parameters, + STATE(1316), 1, + sym_nullable_type, + STATE(1389), 1, + sym_parameter_type_list, + STATE(1244), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2411), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60663] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1245), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3068), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3066), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60721] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1246), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2860), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2858), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60779] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1247), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2888), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2886), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60837] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1248), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2916), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2914), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60895] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(389), 1, + sym_multiplicative_operator, + STATE(1256), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1249), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2527), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2525), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [60963] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1687), 1, + anon_sym_BANG, + ACTIONS(3015), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1250), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1681), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1711), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1713), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61027] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1698), 1, + anon_sym_BANG, + ACTIONS(3021), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1251), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1692), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1694), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1696), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61091] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1252), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3108), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3106), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61149] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1253), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3088), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3086), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61207] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1254), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2900), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2898), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61265] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1255), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1891), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1889), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61323] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2550), 1, + anon_sym_SLASH, + STATE(389), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(2547), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + STATE(1256), 3, + sym_comment, + sym_documentation_comment, + aux_sym_multiplicative_expression_repeat1, + ACTIONS(2545), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2543), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61389] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1257), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2936), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2934), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61447] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1258), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3092), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3090), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61505] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3229), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1259), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3226), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(3036), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3034), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [61567] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3235), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1260), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3232), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(3040), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3038), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [61629] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1261), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2990), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2988), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61687] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1262), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2924), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2922), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61745] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1263), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2940), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2938), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61803] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1264), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3056), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3054), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61861] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1265), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2976), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2974), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61919] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1266), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3084), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3082), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [61977] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1687), 1, + anon_sym_BANG, + ACTIONS(3027), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(1267), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1681), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1683), 5, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1685), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62041] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3241), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1268), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3238), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(3060), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3058), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [62103] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3247), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1269), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3244), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(3064), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(3062), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [62165] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1270), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1053), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1051), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62223] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1271), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2986), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2984), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62281] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1272), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2884), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2882), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62339] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1273), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2912), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2910), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62397] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1274), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3096), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3094), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62455] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3250), 1, + anon_sym_QMARK, + ACTIONS(3253), 1, + anon_sym_LT, + STATE(1315), 1, + sym_type_parameters, + STATE(1323), 1, + sym_nullable_type, + STATE(1389), 1, + sym_parameter_type_list, + STATE(1275), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2429), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62525] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1276), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2972), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2970), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62583] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1277), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2626), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2622), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62641] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3259), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1278), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3256), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2916), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2914), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [62703] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1279), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2632), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2628), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62761] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3265), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1280), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3262), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2884), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2882), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [62823] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1281), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3270), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3268), 21, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_throw, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + sym_rethrow_builtin, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [62881] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1282), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1703), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1705), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62939] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1283), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3104), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3102), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [62997] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1284), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1006), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63055] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1285), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3076), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3074), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63113] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1286), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2928), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2926), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63171] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1287), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2832), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2830), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63229] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1288), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2872), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2870), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63287] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1289), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3116), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3114), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63345] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1290), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2816), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2812), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63403] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(3279), 1, + sym_hex_integer_literal, + STATE(1327), 1, + sym_super, + STATE(2150), 1, + sym__numeric_literal, + ACTIONS(3276), 2, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + STATE(1291), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 12, + anon_sym_POUND, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 16, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [63471] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3285), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1292), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3282), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2876), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2874), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [63533] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1293), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3032), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3030), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63591] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1459), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1294), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1462), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(1332), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1322), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [63653] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1295), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3100), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3098), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63711] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1296), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1687), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1681), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63769] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3291), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1297), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3288), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2912), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2910), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [63831] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1298), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(997), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(999), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63889] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1299), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2944), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2942), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [63947] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1300), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2952), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2950), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64005] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1301), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3080), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3078), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64063] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1302), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1733), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1731), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64121] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3297), 2, + anon_sym_QMARK, + anon_sym_BANG, + STATE(1303), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3294), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2936), 8, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2934), 17, + anon_sym_LBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [64183] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1304), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1679), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1677), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64241] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1305), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1657), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1655), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64299] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1306), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2892), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2890), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64357] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1307), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1291), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1271), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64415] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1308), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3036), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3034), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64473] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1309), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3040), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(3038), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64531] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1310), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1665), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1663), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64589] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1311), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1669), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(1667), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64647] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1312), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + ACTIONS(2694), 26, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64705] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1313), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3302), 5, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_AT, + ACTIONS(3300), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [64762] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1314), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2545), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2543), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64819] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3304), 1, + anon_sym_QMARK, + STATE(1325), 1, + sym_nullable_type, + STATE(1406), 1, + sym_parameter_type_list, + STATE(1315), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64884] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3307), 1, + anon_sym_QMARK, + STATE(1406), 1, + sym_parameter_type_list, + STATE(1422), 1, + sym_nullable_type, + STATE(1316), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2529), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [64949] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1317), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2904), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2902), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65006] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1318), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2856), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2854), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65063] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1319), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2117), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65120] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1320), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2844), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2842), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65177] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1321), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2848), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2846), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65234] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1322), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2033), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65291] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3304), 1, + anon_sym_QMARK, + STATE(1406), 1, + sym_parameter_type_list, + STATE(1422), 1, + sym_nullable_type, + STATE(1323), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65356] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3311), 1, + anon_sym_super, + STATE(1403), 1, + sym_super, + STATE(1324), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [65417] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3216), 1, + anon_sym_LPAREN, + ACTIONS(3313), 1, + anon_sym_QMARK, + STATE(1396), 1, + sym_parameter_type_list, + STATE(1443), 1, + sym_nullable_type, + STATE(1325), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65482] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1004), 1, + anon_sym_EQ, + ACTIONS(999), 2, + anon_sym_while, + anon_sym_else, + STATE(1326), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1008), 10, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1006), 20, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65543] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1327), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2852), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2850), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65600] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3316), 1, + anon_sym_Function, + STATE(1275), 1, + sym__function_builtin_identifier, + STATE(1331), 1, + aux_sym__function_type_tails, + STATE(1440), 1, + sym__function_type_tail, + STATE(1328), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2405), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65665] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + STATE(1332), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + ACTIONS(3320), 2, + anon_sym_LPAREN, + anon_sym_QMARK, + STATE(1329), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3318), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [65728] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3316), 1, + anon_sym_Function, + STATE(1275), 1, + sym__function_builtin_identifier, + STATE(1331), 1, + aux_sym__function_type_tails, + STATE(1440), 1, + sym__function_type_tail, + STATE(1330), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2460), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65793] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3322), 1, + anon_sym_Function, + STATE(1275), 1, + sym__function_builtin_identifier, + STATE(1440), 1, + sym__function_type_tail, + STATE(1331), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2464), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [65856] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3329), 1, + anon_sym_AT, + STATE(1415), 1, + sym_annotation, + ACTIONS(3327), 2, + anon_sym_LPAREN, + anon_sym_QMARK, + STATE(1332), 3, + sym_comment, + sym_documentation_comment, + aux_sym__metadata_repeat1, + ACTIONS(3325), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [65917] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3332), 1, + anon_sym_super, + STATE(913), 1, + sym_super, + STATE(1333), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [65978] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3334), 1, + anon_sym_super, + STATE(1489), 1, + sym_super, + STATE(1334), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [66039] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1335), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1696), 26, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [66096] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(165), 1, + anon_sym_super, + STATE(1327), 1, + sym_super, + STATE(1336), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [66157] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3336), 1, + anon_sym_super, + STATE(1106), 1, + sym_super, + STATE(1337), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 18, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + sym_identifier, + [66218] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3338), 1, + anon_sym_PIPE, + ACTIONS(3340), 1, + anon_sym_AMP, + ACTIONS(3342), 1, + anon_sym_DOT, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(389), 1, + sym_multiplicative_operator, + STATE(1037), 1, + sym_unconditional_assignable_selector, + STATE(1041), 1, + sym_index_selector, + STATE(1249), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1338), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [66324] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(313), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1339), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + ACTIONS(1408), 21, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [66388] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2354), 1, + anon_sym_DOT, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3344), 1, + anon_sym_PIPE, + ACTIONS(3346), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(402), 1, + sym_multiplicative_operator, + STATE(1206), 1, + sym_index_selector, + STATE(1217), 1, + sym_unconditional_assignable_selector, + STATE(1346), 1, + sym__shift_operator, + STATE(1356), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1340), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [66494] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3350), 1, + anon_sym_QMARK, + ACTIONS(3354), 1, + anon_sym_LT, + STATE(1377), 1, + sym_type_parameters, + STATE(1382), 1, + sym_nullable_type, + STATE(1463), 1, + sym_parameter_type_list, + STATE(1341), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 6, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2411), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [66562] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3358), 1, + anon_sym_QMARK, + ACTIONS(3361), 1, + anon_sym_LT, + STATE(1377), 1, + sym_type_parameters, + STATE(1399), 1, + sym_nullable_type, + STATE(1463), 1, + sym_parameter_type_list, + STATE(1342), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 6, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2429), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [66630] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1343), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3366), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3364), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [66686] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3368), 1, + anon_sym_QMARK, + ACTIONS(3371), 1, + anon_sym_LT, + STATE(1388), 1, + sym_type_arguments, + STATE(1448), 1, + sym_nullable_type, + STATE(1344), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2485), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [66750] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1345), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3274), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3272), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [66806] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1346), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3376), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3374), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [66862] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1347), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3380), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3378), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [66918] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3382), 1, + anon_sym_PIPE, + ACTIONS(3384), 1, + anon_sym_AMP, + ACTIONS(3386), 1, + anon_sym_DOT, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(373), 1, + sym_relational_operator, + STATE(386), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1348), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [67024] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(393), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1370), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1349), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2477), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [67090] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1350), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3390), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3388), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [67146] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3392), 1, + anon_sym_DOT, + STATE(1445), 1, + sym__type_dot_identifier, + STATE(1351), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2044), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [67206] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(402), 1, + sym_multiplicative_operator, + STATE(1356), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1352), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2479), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2477), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [67272] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3382), 1, + anon_sym_PIPE, + ACTIONS(3384), 1, + anon_sym_AMP, + ACTIONS(3394), 1, + anon_sym_DOT, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(373), 1, + sym_relational_operator, + STATE(386), 1, + sym_multiplicative_operator, + STATE(844), 1, + sym_index_selector, + STATE(847), 1, + sym_unconditional_assignable_selector, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1353), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [67378] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1354), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1932), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(1934), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [67434] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2312), 1, + anon_sym_LBRACK, + ACTIONS(2324), 1, + anon_sym_DOT, + ACTIONS(2397), 1, + sym_equality_operator, + ACTIONS(2401), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3344), 1, + anon_sym_PIPE, + ACTIONS(3346), 1, + anon_sym_AMP, + STATE(310), 1, + sym_additive_operator, + STATE(371), 1, + sym_relational_operator, + STATE(372), 1, + sym_shift_operator, + STATE(402), 1, + sym_multiplicative_operator, + STATE(664), 1, + sym_unconditional_assignable_selector, + STATE(676), 1, + sym_index_selector, + STATE(1346), 1, + sym__shift_operator, + STATE(1356), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1548), 1, + aux_sym_shift_expression_repeat1, + STATE(1599), 1, + aux_sym_additive_expression_repeat1, + STATE(1647), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1675), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1676), 1, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1355), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [67540] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(402), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1364), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1356), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2527), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2525), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [67606] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1357), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3398), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3396), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [67662] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3382), 1, + anon_sym_PIPE, + ACTIONS(3384), 1, + anon_sym_AMP, + ACTIONS(3400), 1, + anon_sym_DOT, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(373), 1, + sym_relational_operator, + STATE(386), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1358), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [67768] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1359), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3404), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3402), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [67824] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3386), 1, + anon_sym_DOT, + ACTIONS(3406), 1, + anon_sym_PIPE, + ACTIONS(3408), 1, + anon_sym_AMP, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(393), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(803), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1360), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [67930] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1361), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3412), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3410), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [67986] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3386), 1, + anon_sym_DOT, + ACTIONS(3414), 1, + anon_sym_PIPE, + ACTIONS(3416), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(393), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1370), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1362), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68092] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1277), 1, + sym_equality_operator, + ACTIONS(1281), 1, + anon_sym_CARET, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3394), 1, + anon_sym_DOT, + ACTIONS(3406), 1, + anon_sym_PIPE, + ACTIONS(3408), 1, + anon_sym_AMP, + STATE(333), 1, + sym_relational_operator, + STATE(334), 1, + sym_shift_operator, + STATE(335), 1, + sym_additive_operator, + STATE(393), 1, + sym_multiplicative_operator, + STATE(801), 1, + aux_sym_shift_expression_repeat1, + STATE(803), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(817), 1, + aux_sym_additive_expression_repeat1, + STATE(841), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(842), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(843), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(844), 1, + sym_index_selector, + STATE(847), 1, + sym_unconditional_assignable_selector, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1363), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68198] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2550), 1, + anon_sym_SLASH, + STATE(402), 1, + sym_multiplicative_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(2547), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + STATE(1364), 3, + sym_comment, + sym_documentation_comment, + aux_sym_multiplicative_expression_repeat1, + ACTIONS(2545), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2543), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [68262] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(2336), 1, + sym_equality_operator, + ACTIONS(2340), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3394), 1, + anon_sym_DOT, + ACTIONS(3414), 1, + anon_sym_PIPE, + ACTIONS(3416), 1, + anon_sym_AMP, + STATE(321), 1, + sym_relational_operator, + STATE(322), 1, + sym_shift_operator, + STATE(323), 1, + sym_additive_operator, + STATE(393), 1, + sym_multiplicative_operator, + STATE(844), 1, + sym_index_selector, + STATE(847), 1, + sym_unconditional_assignable_selector, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1370), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1538), 1, + aux_sym_shift_expression_repeat1, + STATE(1569), 1, + aux_sym_additive_expression_repeat1, + STATE(1654), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1655), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1656), 1, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1365), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68368] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3418), 1, + anon_sym_PIPE, + ACTIONS(3420), 1, + anon_sym_AMP, + ACTIONS(3422), 1, + anon_sym_DOT, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(399), 1, + sym_multiplicative_operator, + STATE(610), 1, + sym_unconditional_assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(963), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1366), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68474] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2176), 1, + sym_equality_operator, + ACTIONS(2180), 1, + anon_sym_CARET, + ACTIONS(2188), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3338), 1, + anon_sym_PIPE, + ACTIONS(3340), 1, + anon_sym_AMP, + ACTIONS(3422), 1, + anon_sym_DOT, + STATE(348), 1, + sym_relational_operator, + STATE(351), 1, + sym_shift_operator, + STATE(352), 1, + sym_additive_operator, + STATE(389), 1, + sym_multiplicative_operator, + STATE(610), 1, + sym_unconditional_assignable_selector, + STATE(612), 1, + sym_index_selector, + STATE(1249), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1437), 1, + aux_sym_shift_expression_repeat1, + STATE(1470), 1, + aux_sym_additive_expression_repeat1, + STATE(1555), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1557), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1559), 1, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1367), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68580] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(1486), 1, + sym_equality_operator, + ACTIONS(1490), 1, + anon_sym_CARET, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3342), 1, + anon_sym_DOT, + ACTIONS(3418), 1, + anon_sym_PIPE, + ACTIONS(3420), 1, + anon_sym_AMP, + STATE(366), 1, + sym_relational_operator, + STATE(367), 1, + sym_shift_operator, + STATE(368), 1, + sym_additive_operator, + STATE(399), 1, + sym_multiplicative_operator, + STATE(951), 1, + aux_sym_shift_expression_repeat1, + STATE(963), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1010), 1, + aux_sym_additive_expression_repeat1, + STATE(1037), 1, + sym_unconditional_assignable_selector, + STATE(1041), 1, + sym_index_selector, + STATE(1053), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1068), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1079), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1368), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68686] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3382), 1, + anon_sym_PIPE, + ACTIONS(3384), 1, + anon_sym_AMP, + ACTIONS(3424), 1, + anon_sym_DOT, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(373), 1, + sym_relational_operator, + STATE(386), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1369), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68792] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2483), 1, + anon_sym_SLASH, + STATE(393), 1, + sym_multiplicative_operator, + STATE(809), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1370), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(2527), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2525), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [68858] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2048), 1, + anon_sym_LBRACK, + ACTIONS(2148), 1, + sym_equality_operator, + ACTIONS(2152), 1, + anon_sym_CARET, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3382), 1, + anon_sym_PIPE, + ACTIONS(3384), 1, + anon_sym_AMP, + ACTIONS(3426), 1, + anon_sym_DOT, + STATE(313), 1, + sym_shift_operator, + STATE(338), 1, + sym_additive_operator, + STATE(373), 1, + sym_relational_operator, + STATE(386), 1, + sym_multiplicative_operator, + STATE(558), 1, + sym_index_selector, + STATE(562), 1, + sym_unconditional_assignable_selector, + STATE(1195), 1, + aux_sym_multiplicative_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(1373), 1, + aux_sym_shift_expression_repeat1, + STATE(1397), 1, + aux_sym_additive_expression_repeat1, + STATE(1449), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1450), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1461), 1, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1371), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + [68964] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1372), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3430), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3428), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [69020] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(313), 1, + sym_shift_operator, + STATE(1339), 1, + aux_sym_shift_expression_repeat1, + STATE(1346), 1, + sym__shift_operator, + STATE(1373), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2515), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69082] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1374), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3434), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + sym_increment_operator, + anon_sym_BANG, + anon_sym_TILDE, + ACTIONS(3432), 19, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + sym_minus_operator, + anon_sym_await, + anon_sym_switch, + anon_sym_get, + anon_sym_set, + anon_sym_new, + sym_const_builtin, + anon_sym_this, + anon_sym_super, + sym_identifier, + [69138] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1375), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2033), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2019), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69193] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(339), 1, + sym_logical_and_operator, + STATE(1409), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1376), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2614), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69252] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3436), 1, + anon_sym_QMARK, + STATE(1410), 1, + sym_nullable_type, + STATE(1475), 1, + sym_parameter_type_list, + STATE(1377), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2495), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69315] = 36, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1729), 1, + sym__metadata, + STATE(1750), 1, + sym_inferred_type, + STATE(1813), 1, + sym_final_builtin, + STATE(1816), 1, + sym__type_not_function, + STATE(1820), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2675), 1, + sym__declared_identifier, + STATE(2744), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3328), 1, + sym__final_const_var_or_type, + STATE(1378), 2, + sym_comment, + sym_documentation_comment, + STATE(3054), 2, + sym_pattern_variable_declaration, + sym_initialized_variable_definition, + [69426] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + ACTIONS(3441), 1, + anon_sym_QMARK, + STATE(1447), 1, + sym_nullable_type, + STATE(1379), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69487] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1380), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2708), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2706), 25, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69542] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3444), 1, + anon_sym_Function, + STATE(1342), 1, + sym__function_builtin_identifier, + STATE(1384), 1, + aux_sym__function_type_tails, + STATE(1551), 1, + sym__function_type_tail, + STATE(1381), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2405), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69605] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3446), 1, + anon_sym_QMARK, + STATE(1475), 1, + sym_parameter_type_list, + STATE(1516), 1, + sym_nullable_type, + STATE(1382), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2529), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69668] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3444), 1, + anon_sym_Function, + STATE(1342), 1, + sym__function_builtin_identifier, + STATE(1384), 1, + aux_sym__function_type_tails, + STATE(1551), 1, + sym__function_type_tail, + STATE(1383), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2460), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69731] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3450), 1, + anon_sym_Function, + STATE(1342), 1, + sym__function_builtin_identifier, + STATE(1551), 1, + sym__function_type_tail, + STATE(1384), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2464), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69792] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(280), 1, + sym__assignment_operator, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1462), 1, + aux_sym_cascade_section_repeat2, + STATE(1592), 1, + sym__assignable_selector, + STATE(1990), 1, + sym__cascade_assignment_section, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1385), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1133), 4, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1127), 5, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [69863] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1386), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2682), 25, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69918] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1387), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3052), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(3050), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [69973] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3453), 1, + anon_sym_QMARK, + STATE(1420), 1, + sym_nullable_type, + STATE(1388), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2586), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70032] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3304), 1, + anon_sym_QMARK, + STATE(1422), 1, + sym_nullable_type, + STATE(1389), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70091] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1390), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2670), 25, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70146] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1391), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2904), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2902), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70201] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1392), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2117), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2115), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70256] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1393), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3458), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_AT, + ACTIONS(3456), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [70311] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1394), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2844), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2842), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70366] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(340), 1, + sym_logical_or_operator, + STATE(1408), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1395), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2610), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70425] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3460), 1, + anon_sym_QMARK, + STATE(1460), 1, + sym_nullable_type, + STATE(1396), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2553), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70484] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(338), 1, + sym_additive_operator, + STATE(1412), 1, + aux_sym_additive_expression_repeat1, + STATE(1397), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2560), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70543] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1398), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2848), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2846), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70598] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3436), 1, + anon_sym_QMARK, + STATE(1475), 1, + sym_parameter_type_list, + STATE(1516), 1, + sym_nullable_type, + STATE(1399), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2495), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70661] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(3465), 1, + anon_sym_DOT, + STATE(1593), 1, + sym_arguments, + STATE(3207), 1, + sym_type_arguments, + ACTIONS(3195), 2, + anon_sym_AT, + sym_part_of_builtin, + STATE(1400), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3191), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [70726] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1401), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2545), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2543), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70781] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1402), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1893), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_AT, + ACTIONS(1895), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [70836] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1403), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2852), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2850), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70891] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1404), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2726), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2724), 25, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [70946] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1405), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2856), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(2854), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71001] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3313), 1, + anon_sym_QMARK, + STATE(1443), 1, + sym_nullable_type, + STATE(1406), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71060] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1407), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1889), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_AT, + ACTIONS(1891), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [71115] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(340), 1, + sym_logical_or_operator, + STATE(1408), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1389), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + [71174] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(339), 1, + sym_logical_and_operator, + STATE(1409), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1385), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_PIPE_PIPE, + [71233] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3348), 1, + anon_sym_LPAREN, + ACTIONS(3467), 1, + anon_sym_QMARK, + STATE(1471), 1, + sym_parameter_type_list, + STATE(1528), 1, + sym_nullable_type, + STATE(1410), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2505), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71296] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1411), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3472), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_AT, + ACTIONS(3470), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [71351] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(338), 1, + sym_additive_operator, + STATE(1412), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1393), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71410] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(280), 1, + sym__assignment_operator, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1462), 1, + aux_sym_cascade_section_repeat2, + STATE(1592), 1, + sym__assignable_selector, + STATE(1991), 1, + sym__cascade_assignment_section, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1413), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1157), 4, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1155), 5, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [71481] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1414), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_as, + anon_sym_async, + ACTIONS(1696), 22, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71536] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1415), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3476), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_AT, + ACTIONS(3474), 28, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_operator, + anon_sym_mixin, + anon_sym_required, + anon_sym_set, + anon_sym_static, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + anon_sym_this, + anon_sym_super, + sym_identifier, + [71591] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3478), 1, + anon_sym_CARET, + STATE(1416), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1416), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71647] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3485), 1, + anon_sym_AT, + ACTIONS(3488), 1, + anon_sym_part, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1705), 1, + sym_part_directive, + STATE(3632), 1, + sym__metadata, + ACTIONS(3481), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + sym_part_of_builtin, + STATE(1417), 3, + sym_comment, + sym_documentation_comment, + aux_sym_program_repeat2, + ACTIONS(3483), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [71713] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1418), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2756), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71767] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1419), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2694), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71821] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1420), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2822), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71875] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1421), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2698), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71929] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1422), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [71983] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1423), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2702), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72037] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(351), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1424), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_as, + anon_sym_async, + ACTIONS(1408), 17, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72099] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1425), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2760), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72153] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(1426), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72209] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3441), 1, + anon_sym_QMARK, + STATE(1488), 1, + sym_nullable_type, + STATE(1427), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72267] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1428), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2740), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72321] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3491), 1, + anon_sym_DOT, + STATE(1553), 1, + sym__type_dot_identifier, + STATE(1429), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2044), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72379] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1430), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2744), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72433] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3493), 1, + anon_sym_QMARK, + ACTIONS(3496), 1, + anon_sym_LT, + STATE(1508), 1, + sym_type_arguments, + STATE(1554), 1, + sym_nullable_type, + STATE(1431), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 6, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2485), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72495] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1432), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2728), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72549] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1433), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3366), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_minus_operator, + ACTIONS(3364), 17, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_LT, + anon_sym_GT, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + sym_const_builtin, + sym_identifier, + [72603] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1434), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3434), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_minus_operator, + ACTIONS(3432), 17, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_LT, + anon_sym_GT, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + sym_const_builtin, + sym_identifier, + [72657] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3501), 1, + anon_sym_QMARK, + ACTIONS(3505), 1, + anon_sym_LT, + STATE(1472), 1, + sym_nullable_type, + STATE(1498), 1, + sym_type_parameters, + STATE(1603), 1, + sym_parameter_type_list, + STATE(1435), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2411), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72723] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1436), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3511), 13, + anon_sym_POUND, + sym_hex_integer_literal, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_minus_operator, + ACTIONS(3509), 17, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + anon_sym_true, + anon_sym_false, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_null, + anon_sym_LT, + anon_sym_GT, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + sym_const_builtin, + sym_identifier, + [72777] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(351), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1424), 1, + aux_sym_shift_expression_repeat1, + STATE(1437), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2515), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72837] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1438), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2818), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72891] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3513), 1, + anon_sym_QMARK_QMARK, + STATE(1439), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2654), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [72947] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1440), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2618), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73001] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1441), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2710), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73055] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1442), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2674), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73109] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1443), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2553), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73163] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1444), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2714), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73217] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1445), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2678), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73271] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1446), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2748), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73325] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2722), 1, + anon_sym_Function, + STATE(1447), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2718), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73381] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1448), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2586), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73435] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1416), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1449), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2646), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73491] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1456), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1450), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2650), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73547] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1451), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2808), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73601] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3516), 1, + anon_sym_QMARK, + ACTIONS(3519), 1, + anon_sym_LT, + STATE(1485), 1, + sym_nullable_type, + STATE(1498), 1, + sym_type_parameters, + STATE(1603), 1, + sym_parameter_type_list, + STATE(1452), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2429), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73667] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1453), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2686), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73721] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3522), 1, + anon_sym_PIPE, + STATE(1454), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1412), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73777] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1439), 1, + aux_sym__if_null_expression, + STATE(1455), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2638), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73833] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3525), 1, + anon_sym_AMP, + STATE(1456), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + ACTIONS(1424), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73889] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1457), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2752), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73943] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1458), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2690), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [73997] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1459), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2736), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74051] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1460), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2732), 24, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74105] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1454), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1461), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2642), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74161] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1309), 1, + anon_sym_LT, + ACTIONS(2958), 1, + anon_sym_LBRACK, + ACTIONS(2961), 1, + anon_sym_QMARK, + ACTIONS(2964), 1, + anon_sym_DOT, + ACTIONS(2967), 1, + anon_sym_QMARK_DOT, + STATE(1125), 1, + sym__cascade_subsection, + STATE(1142), 1, + sym_index_selector, + STATE(1592), 1, + sym__assignable_selector, + STATE(1143), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1462), 3, + sym_comment, + sym_documentation_comment, + aux_sym_cascade_section_repeat2, + ACTIONS(1304), 18, + anon_sym_LPAREN, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [74230] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3436), 1, + anon_sym_QMARK, + STATE(1516), 1, + sym_nullable_type, + STATE(1463), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2495), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74287] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1464), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2479), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2477), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74340] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(355), 1, + sym_logical_or_operator, + STATE(1477), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1465), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2610), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74397] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(354), 1, + sym_logical_and_operator, + STATE(1492), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1466), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2614), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74454] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1467), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2670), 21, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74507] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(352), 1, + sym_additive_operator, + STATE(1468), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1393), 18, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74564] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1469), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2033), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2019), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74617] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(352), 1, + sym_additive_operator, + STATE(1468), 1, + aux_sym_additive_expression_repeat1, + STATE(1470), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2560), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74674] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3528), 1, + anon_sym_QMARK, + STATE(1541), 1, + sym_nullable_type, + STATE(1471), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2553), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74731] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3531), 1, + anon_sym_QMARK, + STATE(1578), 1, + sym_parameter_type_list, + STATE(1657), 1, + sym_nullable_type, + STATE(1472), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2529), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74792] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1473), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2836), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2834), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74845] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1474), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2726), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2724), 21, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74898] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3467), 1, + anon_sym_QMARK, + STATE(1528), 1, + sym_nullable_type, + STATE(1475), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2505), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [74955] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1476), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2848), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2846), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75008] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(355), 1, + sym_logical_or_operator, + STATE(1477), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1389), 18, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + [75065] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3535), 1, + anon_sym_AT, + STATE(1588), 1, + sym_annotation, + ACTIONS(3327), 2, + anon_sym_LPAREN, + sym_part_of_builtin, + STATE(1478), 3, + sym_comment, + sym_documentation_comment, + aux_sym__metadata_repeat1, + ACTIONS(3325), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [75122] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3538), 1, + anon_sym_DQUOTE, + ACTIONS(3541), 1, + anon_sym_SQUOTE, + ACTIONS(3544), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(3547), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(3550), 1, + anon_sym_r_DQUOTE, + ACTIONS(3553), 1, + anon_sym_r_SQUOTE, + ACTIONS(3556), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(3559), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(1479), 3, + sym_comment, + sym_documentation_comment, + aux_sym_string_literal_repeat1, + STATE(1854), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1261), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75191] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1480), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2868), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2866), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75244] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3564), 1, + anon_sym_QMARK, + ACTIONS(3567), 1, + anon_sym_LT, + STATE(1577), 1, + sym_nullable_type, + STATE(1586), 1, + sym_type_parameters, + STATE(1637), 1, + sym_parameter_type_list, + STATE(1481), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2429), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75309] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1482), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2838), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75362] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3569), 1, + anon_sym_Function, + STATE(1452), 1, + sym__function_builtin_identifier, + STATE(1511), 1, + aux_sym__function_type_tails, + STATE(1635), 1, + sym__function_type_tail, + STATE(1483), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2405), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75423] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(19), 1, + anon_sym_AT, + STATE(1478), 1, + aux_sym__metadata_repeat1, + STATE(1588), 1, + sym_annotation, + ACTIONS(3320), 2, + anon_sym_LPAREN, + sym_part_of_builtin, + STATE(1484), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3318), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [75482] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3571), 1, + anon_sym_QMARK, + STATE(1578), 1, + sym_parameter_type_list, + STATE(1657), 1, + sym_nullable_type, + STATE(1485), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75543] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1486), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(3110), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75596] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(939), 1, + anon_sym_DQUOTE, + ACTIONS(941), 1, + anon_sym_SQUOTE, + ACTIONS(943), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(945), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(947), 1, + anon_sym_r_DQUOTE, + ACTIONS(949), 1, + anon_sym_r_SQUOTE, + ACTIONS(951), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(953), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(1479), 1, + aux_sym_string_literal_repeat1, + STATE(1487), 2, + sym_comment, + sym_documentation_comment, + STATE(1854), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + ACTIONS(1265), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75667] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1488), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2718), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75720] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1489), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2852), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2850), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75773] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1490), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2856), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2854), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [75826] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3578), 1, + anon_sym_AT, + ACTIONS(3581), 1, + sym_part_of_builtin, + STATE(1484), 1, + aux_sym__metadata_repeat1, + STATE(1588), 1, + sym_annotation, + STATE(1732), 1, + sym_part_of_directive, + STATE(3532), 1, + sym__metadata, + ACTIONS(3574), 2, + ts_builtin_sym_end, + anon_sym_LPAREN, + STATE(1491), 3, + sym_comment, + sym_documentation_comment, + aux_sym_program_repeat3, + ACTIONS(3576), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [75891] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(354), 1, + sym_logical_and_operator, + STATE(1492), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1385), 18, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_PIPE_PIPE, + [75948] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3569), 1, + anon_sym_Function, + STATE(1452), 1, + sym__function_builtin_identifier, + STATE(1511), 1, + aux_sym__function_type_tails, + STATE(1635), 1, + sym__function_type_tail, + STATE(1493), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2460), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76009] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1494), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1694), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(1696), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76062] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1495), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2932), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2930), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76115] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1496), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2948), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2946), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76168] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1497), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2844), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2842), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76221] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3571), 1, + anon_sym_QMARK, + STATE(1501), 1, + sym_nullable_type, + STATE(1578), 1, + sym_parameter_type_list, + STATE(1498), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76282] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1499), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2682), 21, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76335] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1500), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2864), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2862), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76388] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3499), 1, + anon_sym_LPAREN, + ACTIONS(3584), 1, + anon_sym_QMARK, + STATE(1591), 1, + sym_parameter_type_list, + STATE(1638), 1, + sym_nullable_type, + STATE(1501), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76449] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3564), 1, + anon_sym_QMARK, + ACTIONS(3567), 1, + anon_sym_LT, + STATE(1565), 1, + sym_nullable_type, + STATE(1586), 1, + sym_type_parameters, + STATE(1637), 1, + sym_parameter_type_list, + STATE(1502), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2411), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76514] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1503), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1397), 23, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76567] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1504), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2708), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2706), 21, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76620] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1505), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3052), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(3050), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76673] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1506), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2904), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2902), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76726] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1507), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2117), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2115), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76779] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3587), 1, + anon_sym_QMARK, + STATE(1514), 1, + sym_nullable_type, + STATE(1508), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2586), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76836] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1509), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2545), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_SLASH, + ACTIONS(2543), 22, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76889] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + ACTIONS(3590), 1, + anon_sym_QMARK, + STATE(1531), 1, + sym_nullable_type, + STATE(1510), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2574), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [76948] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3593), 1, + anon_sym_Function, + STATE(1452), 1, + sym__function_builtin_identifier, + STATE(1635), 1, + sym__function_type_tail, + STATE(1511), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2464), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77007] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1512), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3302), 5, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_DOT, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3300), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [77060] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1513), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2740), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77112] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1514), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2822), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77164] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1515), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2698), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77216] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1516), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2505), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77268] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1517), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2808), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77320] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1518), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2702), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77372] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(1519), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2574), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77426] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1520), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2818), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77478] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3590), 1, + anon_sym_QMARK, + STATE(1610), 1, + sym_nullable_type, + STATE(1521), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 7, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2574), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77534] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1522), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2694), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77586] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3600), 1, + anon_sym_EQ_EQ, + ACTIONS(3602), 1, + anon_sym_LBRACK_RBRACK_EQ, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(2835), 1, + sym_binary_operator, + STATE(3599), 1, + sym__bitwise_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(3598), 2, + anon_sym_TILDE, + anon_sym_LBRACK_RBRACK, + STATE(1523), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(3596), 3, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + STATE(3597), 5, + sym_relational_operator, + sym_bitwise_operator, + sym_shift_operator, + sym_additive_operator, + sym_multiplicative_operator, + [77666] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3604), 1, + anon_sym_DOT, + STATE(1672), 1, + sym__type_dot_identifier, + STATE(1524), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2044), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77722] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3606), 1, + anon_sym_QMARK_QMARK, + STATE(1525), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2654), 18, + anon_sym_LBRACE, + anon_sym_COMMA, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77776] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1526), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2706), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2708), 14, + anon_sym_EQ, + anon_sym_when, + anon_sym_on, + anon_sym_catch, + anon_sym_extends, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + [77828] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1527), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2710), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77880] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1528), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2553), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77932] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1529), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2714), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [77984] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(3197), 1, + anon_sym_LT, + STATE(1645), 1, + sym_type_arguments, + STATE(1730), 1, + sym_nullable_type, + STATE(1530), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2485), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78044] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2722), 1, + anon_sym_Function, + STATE(1531), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2718), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78098] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3609), 1, + anon_sym_PIPE, + STATE(1532), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1412), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78152] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3612), 1, + anon_sym_CARET, + STATE(1533), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1416), 18, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78206] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3615), 1, + anon_sym_AMP, + STATE(1534), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 7, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1424), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78260] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1535), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2724), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(2726), 14, + anon_sym_EQ, + anon_sym_when, + anon_sym_on, + anon_sym_catch, + anon_sym_extends, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + [78312] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3600), 1, + anon_sym_EQ_EQ, + ACTIONS(3620), 1, + anon_sym_LBRACK_RBRACK_EQ, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(3037), 1, + sym_binary_operator, + STATE(3599), 1, + sym__bitwise_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(3618), 2, + anon_sym_TILDE, + anon_sym_LBRACK_RBRACK, + STATE(1536), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(3596), 3, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + STATE(3597), 5, + sym_relational_operator, + sym_bitwise_operator, + sym_shift_operator, + sym_additive_operator, + sym_multiplicative_operator, + [78392] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1537), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3622), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3624), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [78444] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(322), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1539), 1, + aux_sym_shift_expression_repeat1, + STATE(1538), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2515), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78502] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(322), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1539), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1408), 14, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78562] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1540), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2728), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78614] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1541), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2732), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78666] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1542), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2736), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78718] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1543), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2744), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78770] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1544), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2748), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78822] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1545), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2752), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78874] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1546), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2756), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78926] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1547), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2760), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [78978] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + STATE(1560), 1, + aux_sym_shift_expression_repeat1, + STATE(1548), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2517), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2515), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79036] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3626), 1, + anon_sym_QMARK, + ACTIONS(3629), 1, + anon_sym_LT, + STATE(1587), 1, + sym_type_arguments, + STATE(1628), 1, + sym_nullable_type, + STATE(1549), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 4, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2485), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79096] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1525), 1, + aux_sym__if_null_expression, + STATE(1550), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2638), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79150] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1551), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2618), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79202] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1552), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2674), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79254] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1553), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2678), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79306] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1554), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2586), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79358] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1532), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1555), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2642), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79412] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1556), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2686), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79464] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1533), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1557), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2646), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79518] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1558), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2690), 20, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79570] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1534), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1559), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2650), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79624] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2522), 1, + anon_sym_GT_GT, + STATE(372), 1, + sym_shift_operator, + STATE(1346), 1, + sym__shift_operator, + ACTIONS(2519), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + STATE(1560), 3, + sym_comment, + sym_documentation_comment, + aux_sym_shift_expression_repeat1, + ACTIONS(1410), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + ACTIONS(1408), 17, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [79684] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3600), 1, + anon_sym_EQ_EQ, + ACTIONS(3634), 1, + anon_sym_LBRACK_RBRACK_EQ, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(2987), 1, + sym_binary_operator, + STATE(3599), 1, + sym__bitwise_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(3632), 2, + anon_sym_TILDE, + anon_sym_LBRACK_RBRACK, + STATE(1561), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(3596), 3, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + STATE(3597), 5, + sym_relational_operator, + sym_bitwise_operator, + sym_shift_operator, + sym_additive_operator, + sym_multiplicative_operator, + [79764] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1287), 1, + anon_sym_GT_GT, + ACTIONS(1289), 1, + sym__additive_operator, + ACTIONS(2483), 1, + anon_sym_SLASH, + ACTIONS(3600), 1, + anon_sym_EQ_EQ, + ACTIONS(3638), 1, + anon_sym_LBRACK_RBRACK_EQ, + STATE(1346), 1, + sym__shift_operator, + STATE(1359), 1, + sym__multiplicative_operator, + STATE(2991), 1, + sym_binary_operator, + STATE(3599), 1, + sym__bitwise_operator, + ACTIONS(368), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(370), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(1285), 2, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + ACTIONS(3636), 2, + anon_sym_TILDE, + anon_sym_LBRACK_RBRACK, + STATE(1562), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2481), 3, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + ACTIONS(3596), 3, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + STATE(3597), 5, + sym_relational_operator, + sym_bitwise_operator, + sym_shift_operator, + sym_additive_operator, + sym_multiplicative_operator, + [79844] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(15), 1, + sym_identifier, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3640), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1968), 1, + sym__late_builtin, + STATE(2019), 1, + sym__final_or_const, + STATE(2407), 1, + sym__get, + STATE(2449), 1, + sym__set, + STATE(2466), 1, + sym__type, + STATE(2623), 1, + sym_setter_signature, + STATE(2693), 1, + sym_final_builtin, + STATE(3020), 1, + sym_inferred_type, + STATE(1563), 2, + sym_comment, + sym_documentation_comment, + STATE(2545), 2, + sym_getter_signature, + sym_function_signature, + [79946] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(312), 1, + sym_logical_or_operator, + STATE(1564), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1389), 18, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + [80001] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3642), 1, + anon_sym_QMARK, + STATE(1649), 1, + sym_parameter_type_list, + STATE(1689), 1, + sym_nullable_type, + STATE(1565), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2529), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80060] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1566), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 13, + anon_sym_EQ, + anon_sym_when, + anon_sym_catch, + anon_sym_extends, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2682), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80111] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(325), 1, + sym_logical_or_operator, + STATE(1573), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1567), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2610), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80166] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(324), 1, + sym_logical_and_operator, + STATE(1574), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1568), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2614), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80221] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(323), 1, + sym_additive_operator, + STATE(1576), 1, + aux_sym_additive_expression_repeat1, + STATE(1569), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2560), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80276] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1570), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3645), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3647), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80327] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1571), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3649), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3651), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80378] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1572), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3653), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3655), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80429] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2607), 1, + anon_sym_PIPE_PIPE, + STATE(325), 1, + sym_logical_or_operator, + STATE(1573), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_or_expression_repeat1, + ACTIONS(1391), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1389), 15, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + [80484] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(324), 1, + sym_logical_and_operator, + STATE(1574), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1385), 15, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_PIPE_PIPE, + [80539] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1575), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3657), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3659), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80590] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(323), 1, + sym_additive_operator, + STATE(1576), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1393), 15, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80645] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3642), 1, + anon_sym_QMARK, + STATE(1649), 1, + sym_parameter_type_list, + STATE(1689), 1, + sym_nullable_type, + STATE(1577), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2495), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80704] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3584), 1, + anon_sym_QMARK, + STATE(1638), 1, + sym_nullable_type, + STATE(1578), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80759] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1579), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(3110), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80810] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1580), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3661), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3663), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80861] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1581), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3665), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3667), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [80912] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1582), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2479), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2477), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [80963] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1583), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2838), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81014] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1584), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2932), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2930), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81065] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1585), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3669), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3671), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [81116] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3642), 1, + anon_sym_QMARK, + STATE(1614), 1, + sym_nullable_type, + STATE(1649), 1, + sym_parameter_type_list, + STATE(1586), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2495), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81175] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3673), 1, + anon_sym_QMARK, + STATE(1666), 1, + sym_nullable_type, + STATE(1587), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2586), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81230] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1588), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3476), 3, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3474), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [81281] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3676), 1, + anon_sym_Function, + STATE(1481), 1, + sym__function_builtin_identifier, + STATE(1702), 1, + sym__function_type_tail, + STATE(1589), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + ACTIONS(2466), 10, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2464), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81338] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1590), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3679), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3681), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [81389] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3683), 1, + anon_sym_QMARK, + STATE(1640), 1, + sym_nullable_type, + STATE(1591), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2553), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81444] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1382), 1, + anon_sym_LT, + ACTIONS(3686), 1, + anon_sym_LPAREN, + STATE(1129), 1, + sym_argument_part, + STATE(1156), 1, + sym_arguments, + STATE(1606), 1, + aux_sym_cascade_section_repeat1, + STATE(3318), 1, + sym_type_arguments, + STATE(1592), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1380), 3, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1375), 18, + anon_sym_LBRACK, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [81507] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1593), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3458), 3, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3456), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [81558] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1594), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2726), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2724), 21, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81609] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1595), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3689), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3691), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [81660] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(312), 1, + sym_logical_or_operator, + STATE(1564), 1, + aux_sym_logical_or_expression_repeat1, + STATE(1596), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2612), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2610), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81715] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(311), 1, + sym_logical_and_operator, + STATE(1619), 1, + aux_sym_logical_and_expression_repeat1, + STATE(1597), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2616), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2614), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81770] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1598), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2684), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2682), 21, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81821] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(310), 1, + sym_additive_operator, + STATE(1620), 1, + aux_sym_additive_expression_repeat1, + STATE(1599), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2562), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2560), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81876] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + ACTIONS(3693), 1, + anon_sym_QMARK, + STATE(1660), 1, + sym_nullable_type, + STATE(1600), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81933] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1601), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2708), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2706), 21, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [81984] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1602), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2836), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2834), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82035] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3571), 1, + anon_sym_QMARK, + STATE(1657), 1, + sym_nullable_type, + STATE(1603), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2495), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82090] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1604), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2948), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2946), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82141] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1481), 1, + sym__function_builtin_identifier, + STATE(1589), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1605), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2407), 10, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2405), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82200] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1372), 1, + anon_sym_LT, + ACTIONS(3696), 1, + anon_sym_LPAREN, + STATE(887), 1, + aux_sym_cascade_section_repeat1, + STATE(1129), 1, + sym_argument_part, + STATE(1156), 1, + sym_arguments, + STATE(3318), 1, + sym_type_arguments, + STATE(1606), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1370), 3, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1365), 18, + anon_sym_LBRACK, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + [82263] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1607), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 12, + anon_sym_EQ, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2678), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82314] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1608), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3699), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3701), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [82365] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1609), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2864), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2862), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82416] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1610), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2718), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82467] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1611), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2868), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(2866), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82518] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1612), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3703), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3705), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [82569] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1613), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2670), 21, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82620] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3562), 1, + anon_sym_LPAREN, + ACTIONS(3707), 1, + anon_sym_QMARK, + STATE(1644), 1, + sym_parameter_type_list, + STATE(1700), 1, + sym_nullable_type, + STATE(1614), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2505), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82679] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1615), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_as, + anon_sym_async, + ACTIONS(1397), 19, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82730] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1616), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3710), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3712), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [82781] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1617), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1055), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(1057), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [82832] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1618), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3714), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3716), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [82883] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2564), 1, + anon_sym_AMP_AMP, + STATE(311), 1, + sym_logical_and_operator, + STATE(1619), 3, + sym_comment, + sym_documentation_comment, + aux_sym_logical_and_expression_repeat1, + ACTIONS(1387), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1385), 18, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_PIPE_PIPE, + [82938] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2604), 1, + sym__additive_operator, + STATE(310), 1, + sym_additive_operator, + STATE(1620), 3, + sym_comment, + sym_documentation_comment, + aux_sym_additive_expression_repeat1, + ACTIONS(1395), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1393), 18, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [82993] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1621), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3472), 3, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3470), 24, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_library, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [83044] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1622), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3718), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3720), 23, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_export, + anon_sym_Function, + anon_sym_get, + anon_sym_import, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [83095] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1481), 1, + sym__function_builtin_identifier, + STATE(1589), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1623), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2462), 10, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2460), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83154] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1624), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2714), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83204] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3722), 1, + anon_sym_CARET, + STATE(1625), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1416), 15, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83256] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3725), 1, + anon_sym_AMP, + STATE(1626), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1424), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83308] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1627), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2698), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83358] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1628), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2586), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83408] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1629), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2808), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83458] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(1723), 1, + anon_sym_static, + ACTIONS(3728), 1, + sym_identifier, + ACTIONS(3731), 1, + anon_sym_LPAREN, + ACTIONS(3734), 1, + sym_void_type, + ACTIONS(3737), 1, + anon_sym_Function, + ACTIONS(3742), 1, + sym_const_builtin, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1561), 1, + sym__operator, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2468), 1, + sym__static, + STATE(3295), 1, + sym__type, + STATE(3584), 1, + sym__factory, + ACTIONS(3740), 2, + anon_sym_get, + anon_sym_set, + STATE(1630), 2, + sym_comment, + sym_documentation_comment, + STATE(3559), 4, + sym_operator_signature, + sym_factory_constructor_signature, + sym_constructor_signature, + sym_constant_constructor_signature, + [83548] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1631), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2740), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83598] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1632), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2744), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83648] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2581), 1, + anon_sym_Function, + STATE(1633), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83700] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1634), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2686), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83750] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1635), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2618), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83800] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1636), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2710), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83850] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3642), 1, + anon_sym_QMARK, + STATE(1689), 1, + sym_nullable_type, + STATE(1637), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2495), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83904] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1638), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2553), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [83954] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1639), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2728), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84004] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1640), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2732), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84054] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1641), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2818), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84104] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1642), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2810), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2808), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84154] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1643), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2820), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2818), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84204] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3744), 1, + anon_sym_QMARK, + STATE(1725), 1, + sym_nullable_type, + STATE(1644), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2553), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84258] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(1736), 1, + sym_nullable_type, + STATE(1645), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2586), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84312] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3747), 1, + anon_sym_QMARK_QMARK, + STATE(1646), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2654), 15, + anon_sym_LBRACK, + anon_sym_LPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84364] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1671), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1647), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2650), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84416] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1648), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 11, + anon_sym_EQ, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2690), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84466] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3707), 1, + anon_sym_QMARK, + STATE(1700), 1, + sym_nullable_type, + STATE(1649), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2505), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84520] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1650), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2694), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84570] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1651), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2736), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84620] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3693), 1, + anon_sym_QMARK, + STATE(1695), 1, + sym_nullable_type, + STATE(1652), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 5, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2574), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84674] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1646), 1, + aux_sym__if_null_expression, + STATE(1653), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2638), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84726] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1668), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1654), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2642), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84778] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1625), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1655), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2646), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84830] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1626), 1, + aux_sym_bitwise_and_expression_repeat1, + STATE(1656), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2652), 9, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2650), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84882] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1657), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2505), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84932] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1658), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2702), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [84982] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1659), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2756), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85032] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2722), 1, + anon_sym_Function, + STATE(1660), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2718), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85084] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1661), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2672), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2670), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85134] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3750), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(1662), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 10, + anon_sym_EQ, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2044), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85188] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1663), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2748), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85238] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3752), 1, + anon_sym_QMARK_QMARK, + STATE(1664), 3, + aux_sym__if_null_expression, + sym_comment, + sym_documentation_comment, + ACTIONS(2659), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2654), 18, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85290] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1665), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2752), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85340] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1666), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2822), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85390] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1667), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2696), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2694), 15, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85440] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3755), 1, + anon_sym_PIPE, + STATE(1668), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 8, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(1412), 16, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85492] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3758), 1, + anon_sym_PIPE, + STATE(1669), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_or_expression_repeat1, + ACTIONS(1414), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1412), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85544] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3761), 1, + anon_sym_CARET, + STATE(1670), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_xor_expression_repeat1, + ACTIONS(1418), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1416), 18, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85596] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3764), 1, + anon_sym_AMP, + STATE(1671), 3, + sym_comment, + sym_documentation_comment, + aux_sym_bitwise_and_expression_repeat1, + ACTIONS(1426), 5, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_GT_GT, + ACTIONS(1424), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85648] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1672), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2680), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2678), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85698] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1673), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2760), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85748] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1674), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2690), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85798] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1669), 1, + aux_sym_bitwise_or_expression_repeat1, + STATE(1675), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2644), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2642), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85850] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1670), 1, + aux_sym_bitwise_xor_expression_repeat1, + STATE(1676), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2648), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2646), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85902] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1677), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2674), 20, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_Function, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [85952] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1664), 1, + aux_sym__if_null_expression, + STATE(1678), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2640), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2638), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86004] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1679), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(1397), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86053] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1680), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2948), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2946), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86102] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3771), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2854), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3493), 1, + sym_optional_parameter_types, + STATE(1681), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86195] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1682), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2762), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2760), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86244] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3773), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3620), 1, + sym_optional_parameter_types, + STATE(1683), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86337] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3775), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3468), 1, + sym_optional_parameter_types, + STATE(1684), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86430] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1685), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2688), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2686), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86479] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1686), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2704), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2702), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86528] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3777), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3339), 1, + sym_optional_parameter_types, + STATE(1687), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86621] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1688), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3779), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3781), 21, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [86670] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1689), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2505), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86719] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3783), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(3010), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3555), 1, + sym_optional_parameter_types, + STATE(1690), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86812] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1691), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2700), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2698), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [86861] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3785), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3506), 1, + sym_optional_parameter_types, + STATE(1692), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [86954] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3787), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3526), 1, + sym_optional_parameter_types, + STATE(1693), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87047] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1694), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2712), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2710), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87096] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1695), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2718), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87145] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1696), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2864), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2862), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87194] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3789), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2901), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3489), 1, + sym_optional_parameter_types, + STATE(1697), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87287] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1698), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2868), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2866), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87336] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1699), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2738), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2736), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87385] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1700), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2558), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2553), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87434] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1701), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2730), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2728), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87483] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1702), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2620), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2618), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [87532] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3791), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3577), 1, + sym_optional_parameter_types, + STATE(1703), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87625] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3793), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2777), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3505), 1, + sym_optional_parameter_types, + STATE(1704), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87718] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1705), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3795), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3797), 21, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [87767] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3799), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3609), 1, + sym_optional_parameter_types, + STATE(1706), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87860] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3801), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3336), 1, + sym_optional_parameter_types, + STATE(1707), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [87953] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1708), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2750), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2748), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88002] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1709), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2836), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2834), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88051] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1710), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2754), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2752), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88100] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1711), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(3110), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88149] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1712), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2838), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88198] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3803), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2944), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3353), 1, + sym_optional_parameter_types, + STATE(1713), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88291] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3805), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3377), 1, + sym_optional_parameter_types, + STATE(1714), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88384] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3807), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3381), 1, + sym_optional_parameter_types, + STATE(1715), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88477] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3809), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2960), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3396), 1, + sym_optional_parameter_types, + STATE(1716), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88570] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1717), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2742), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2740), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88619] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3811), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3412), 1, + sym_optional_parameter_types, + STATE(1718), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88712] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(3767), 1, + anon_sym_LBRACE, + ACTIONS(3769), 1, + anon_sym_LBRACK, + ACTIONS(3813), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(3415), 1, + sym_optional_parameter_types, + STATE(1719), 2, + sym_comment, + sym_documentation_comment, + STATE(3579), 2, + sym_optional_positional_parameter_types, + sym_named_parameter_types, + [88805] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1720), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2746), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2744), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88854] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1721), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2758), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2756), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [88903] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1722), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3815), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3817), 21, + anon_sym_part, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [88952] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1723), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2676), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2674), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89001] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1724), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2479), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2477), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89050] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1725), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2734), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2732), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89099] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1726), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2932), 6, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_GT, + anon_sym_PIPE, + anon_sym_AMP, + anon_sym_GT_GT, + ACTIONS(2930), 19, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK_QMARK, + sym_equality_operator, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_CARET, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_is, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89148] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1727), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2716), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2714), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89197] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1728), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3819), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3821), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89245] = 30, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(153), 1, + anon_sym_covariant, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1822), 1, + sym__covariant, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2744), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3603), 1, + sym__final_const_var_or_type, + STATE(1729), 2, + sym_comment, + sym_documentation_comment, + [89337] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1730), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2586), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89385] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1263), 1, + anon_sym_QMARK, + ACTIONS(3823), 1, + anon_sym_DQUOTE, + ACTIONS(3826), 1, + anon_sym_SQUOTE, + ACTIONS(3829), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(3832), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(3835), 1, + anon_sym_r_DQUOTE, + ACTIONS(3838), 1, + anon_sym_r_SQUOTE, + ACTIONS(3841), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(3844), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(1731), 3, + sym_comment, + sym_documentation_comment, + aux_sym_string_literal_repeat1, + ACTIONS(1261), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + STATE(2026), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [89451] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1732), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3847), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3849), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89499] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(710), 1, + anon_sym_DQUOTE, + ACTIONS(712), 1, + anon_sym_SQUOTE, + ACTIONS(714), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(716), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(718), 1, + anon_sym_r_DQUOTE, + ACTIONS(720), 1, + anon_sym_r_SQUOTE, + ACTIONS(722), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(724), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(3853), 1, + anon_sym_async, + STATE(590), 1, + aux_sym_string_literal_repeat1, + STATE(2552), 1, + sym_string_literal, + STATE(1733), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3851), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(747), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [89569] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1734), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3855), 4, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + sym_part_of_builtin, + ACTIONS(3857), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89617] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1087), 1, + anon_sym_DQUOTE, + ACTIONS(1089), 1, + anon_sym_SQUOTE, + ACTIONS(1091), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1093), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(1095), 1, + anon_sym_r_DQUOTE, + ACTIONS(1097), 1, + anon_sym_r_SQUOTE, + ACTIONS(1099), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(1101), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(1267), 1, + anon_sym_QMARK, + STATE(1731), 1, + aux_sym_string_literal_repeat1, + STATE(1735), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1265), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + STATE(2026), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [89685] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1736), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2824), 11, + anon_sym_when, + anon_sym_catch, + anon_sym_with, + anon_sym_Function, + anon_sym_get, + anon_sym_implements, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2822), 13, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [89733] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1737), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3859), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3861), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89780] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1738), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3863), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3865), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89827] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1739), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3867), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3869), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89874] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1740), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3871), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3873), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89921] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1741), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3875), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3877), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [89968] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1742), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3879), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3881), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90015] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1743), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3883), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3885), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90062] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1744), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3887), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3889), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90109] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1745), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3891), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3893), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90156] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(955), 1, + anon_sym_LBRACE, + ACTIONS(959), 1, + anon_sym_LBRACK, + ACTIONS(963), 1, + anon_sym_LPAREN, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3895), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2418), 1, + sym__type_name, + STATE(2742), 1, + sym__type, + STATE(3063), 1, + sym_type_arguments, + STATE(3289), 1, + sym__outer_pattern, + STATE(1746), 2, + sym_comment, + sym_documentation_comment, + STATE(3229), 5, + sym__parenthesized_pattern, + sym_list_pattern, + sym_map_pattern, + sym_record_pattern, + sym_object_pattern, + [90237] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1747), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3898), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3900), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90284] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1748), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3902), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3904), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90331] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1749), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3906), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3908), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90378] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(955), 1, + anon_sym_LBRACE, + ACTIONS(959), 1, + anon_sym_LBRACK, + ACTIONS(963), 1, + anon_sym_LPAREN, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3895), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2418), 1, + sym__type_name, + STATE(2742), 1, + sym__type, + STATE(3063), 1, + sym_type_arguments, + STATE(3341), 1, + sym__outer_pattern, + STATE(1750), 2, + sym_comment, + sym_documentation_comment, + STATE(3229), 5, + sym__parenthesized_pattern, + sym_list_pattern, + sym_map_pattern, + sym_record_pattern, + sym_object_pattern, + [90459] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1751), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3910), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3912), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90506] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1752), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3914), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3916), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90553] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1753), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3918), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3920), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90600] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1754), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3922), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3924), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90647] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1755), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3926), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3928), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90694] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1756), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3930), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3932), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90741] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1757), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3934), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3936), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90788] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1758), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3938), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3940), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90835] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1759), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3942), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3944), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90882] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1760), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3946), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3948), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90929] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1761), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3950), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3952), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [90976] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(955), 1, + anon_sym_LBRACE, + ACTIONS(959), 1, + anon_sym_LBRACK, + ACTIONS(963), 1, + anon_sym_LPAREN, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3954), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2418), 1, + sym__type_name, + STATE(2730), 1, + sym__type, + STATE(3063), 1, + sym_type_arguments, + STATE(3289), 1, + sym__outer_pattern, + STATE(1762), 2, + sym_comment, + sym_documentation_comment, + STATE(3229), 5, + sym__parenthesized_pattern, + sym_list_pattern, + sym_map_pattern, + sym_record_pattern, + sym_object_pattern, + [91057] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1763), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3957), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3959), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91104] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1764), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3961), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3963), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91151] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1765), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3965), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3967), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91198] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1766), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3969), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3971), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91245] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1767), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3973), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3975), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91292] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1768), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3977), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3979), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91339] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1769), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3981), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3983), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91386] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1770), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3985), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3987), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91433] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1771), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3989), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3991), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91480] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1772), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3993), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3995), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91527] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1773), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3997), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(3999), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91574] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1774), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4001), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4003), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91621] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1775), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4005), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4007), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91668] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1776), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4009), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4011), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91715] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1777), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4013), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4015), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91762] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1778), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4017), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4019), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91809] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1779), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4021), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4023), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91856] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1780), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4025), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4027), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91903] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1781), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4029), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4031), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91950] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1782), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4033), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4035), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [91997] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1783), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4037), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4039), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92044] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1784), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4041), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4043), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92091] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1785), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4045), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4047), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92138] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1786), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4049), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4051), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92185] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1787), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4053), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4055), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92232] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1788), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4057), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4059), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92279] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1789), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4061), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4063), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92326] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1790), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4065), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4067), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92373] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1791), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4069), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4071), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92420] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1792), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4073), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4075), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92467] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1793), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4077), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4079), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92514] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1794), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4081), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4083), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92561] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1795), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4085), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4087), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92608] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1796), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4089), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4091), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92655] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1797), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4093), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4095), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92702] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1798), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4097), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4099), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92749] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1799), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4101), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4103), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92796] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1800), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4105), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4107), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92843] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1801), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4109), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4111), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92890] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1802), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4113), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4115), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92937] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1803), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4117), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4119), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [92984] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1804), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4121), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4123), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93031] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1805), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4125), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4127), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93078] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1806), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4129), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4131), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93125] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1807), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4133), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4135), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93172] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1808), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4137), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4139), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93219] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1809), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4141), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4143), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93266] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1810), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4145), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4147), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93313] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1811), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4149), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4151), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93360] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1812), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4153), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4155), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93407] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(955), 1, + anon_sym_LBRACE, + ACTIONS(959), 1, + anon_sym_LBRACK, + ACTIONS(963), 1, + anon_sym_LPAREN, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3954), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2418), 1, + sym__type_name, + STATE(2730), 1, + sym__type, + STATE(3063), 1, + sym_type_arguments, + STATE(3341), 1, + sym__outer_pattern, + STATE(1813), 2, + sym_comment, + sym_documentation_comment, + STATE(3229), 5, + sym__parenthesized_pattern, + sym_list_pattern, + sym_map_pattern, + sym_record_pattern, + sym_object_pattern, + [93488] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1814), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4157), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4159), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93535] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1815), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4161), 3, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4163), 20, + anon_sym_enum, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_extension, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_interface, + anon_sym_base, + anon_sym_abstract, + anon_sym_sealed, + anon_sym_mixin, + anon_sym_set, + anon_sym_typedef, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [93582] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1481), 1, + sym__function_builtin_identifier, + STATE(1623), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4165), 7, + anon_sym_when, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(4167), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [93636] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4169), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1989), 1, + sym__metadata, + STATE(2031), 1, + sym__required, + STATE(3105), 1, + sym_typed_identifier, + STATE(3240), 1, + sym__named_parameter_type, + STATE(3422), 1, + sym__type, + STATE(1817), 2, + sym_comment, + sym_documentation_comment, + [93722] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4171), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1989), 1, + sym__metadata, + STATE(2031), 1, + sym__required, + STATE(3105), 1, + sym_typed_identifier, + STATE(3240), 1, + sym__named_parameter_type, + STATE(3422), 1, + sym__type, + STATE(1818), 2, + sym_comment, + sym_documentation_comment, + [93808] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(4173), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2948), 1, + sym__var_or_type, + STATE(3344), 1, + sym__type, + STATE(3603), 1, + sym__final_const_var_or_type, + STATE(1819), 2, + sym_comment, + sym_documentation_comment, + [93894] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2744), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3482), 1, + sym__final_const_var_or_type, + STATE(1820), 2, + sym_comment, + sym_documentation_comment, + [93980] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2744), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3603), 1, + sym__final_const_var_or_type, + STATE(1821), 2, + sym_comment, + sym_documentation_comment, + [94066] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2744), 1, + sym__type, + STATE(2948), 1, + sym__var_or_type, + STATE(3398), 1, + sym__final_const_var_or_type, + STATE(1822), 2, + sym_comment, + sym_documentation_comment, + [94152] = 28, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(2277), 1, + sym_const_builtin, + ACTIONS(4173), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1945), 1, + sym__late_builtin, + STATE(2009), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2948), 1, + sym__var_or_type, + STATE(3344), 1, + sym__type, + STATE(3482), 1, + sym__final_const_var_or_type, + STATE(1823), 2, + sym_comment, + sym_documentation_comment, + [94238] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4175), 1, + sym_identifier, + ACTIONS(4178), 1, + anon_sym_LPAREN, + ACTIONS(4181), 1, + sym_void_type, + ACTIONS(4186), 1, + anon_sym_Function, + ACTIONS(4189), 1, + anon_sym_get, + ACTIONS(4192), 1, + anon_sym_static, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1993), 1, + sym__static, + STATE(3308), 1, + sym__type, + STATE(3559), 1, + sym_getter_signature, + STATE(3612), 1, + sym__get, + STATE(1824), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4184), 4, + anon_sym_factory, + anon_sym_operator, + anon_sym_set, + sym_const_builtin, + [94318] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(1941), 1, + anon_sym_GT, + ACTIONS(4195), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2741), 1, + sym_type_parameter, + STATE(2913), 1, + sym__type, + STATE(1825), 2, + sym_comment, + sym_documentation_comment, + [94401] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4197), 1, + sym_identifier, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2495), 1, + sym_string_literal, + STATE(1826), 2, + sym_comment, + sym_documentation_comment, + STATE(3125), 2, + sym_uri, + sym_dotted_identifier_list, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [94468] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4199), 1, + sym_identifier, + ACTIONS(4202), 1, + anon_sym_LBRACE, + ACTIONS(4204), 1, + anon_sym_LBRACK, + ACTIONS(4206), 1, + anon_sym_LPAREN, + STATE(962), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2384), 1, + sym__type_not_function, + STATE(2459), 1, + sym_function_type, + STATE(2696), 1, + sym__type_not_void, + STATE(2730), 1, + sym__type, + STATE(3268), 1, + sym_type_arguments, + ACTIONS(4208), 2, + anon_sym_this, + anon_sym_super, + STATE(1827), 2, + sym_comment, + sym_documentation_comment, + [94549] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1989), 1, + sym__metadata, + STATE(2031), 1, + sym__required, + STATE(2763), 1, + sym__named_parameter_type, + STATE(3105), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1828), 2, + sym_comment, + sym_documentation_comment, + [94632] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4197), 1, + sym_identifier, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2495), 1, + sym_string_literal, + STATE(1829), 2, + sym_comment, + sym_documentation_comment, + STATE(3317), 2, + sym_uri, + sym_dotted_identifier_list, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [94699] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(1911), 1, + sym_nullable_type, + STATE(1830), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4210), 8, + anon_sym_when, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2581), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [94748] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4199), 1, + sym_identifier, + ACTIONS(4212), 1, + anon_sym_LBRACE, + ACTIONS(4214), 1, + anon_sym_LBRACK, + ACTIONS(4216), 1, + anon_sym_LPAREN, + STATE(962), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2384), 1, + sym__type_not_function, + STATE(2459), 1, + sym_function_type, + STATE(2696), 1, + sym__type_not_void, + STATE(2730), 1, + sym__type, + STATE(3069), 1, + sym_type_arguments, + ACTIONS(4208), 2, + anon_sym_this, + anon_sym_super, + STATE(1831), 2, + sym_comment, + sym_documentation_comment, + [94829] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1989), 1, + sym__metadata, + STATE(2031), 1, + sym__required, + STATE(3105), 1, + sym_typed_identifier, + STATE(3240), 1, + sym__named_parameter_type, + STATE(3422), 1, + sym__type, + STATE(1832), 2, + sym_comment, + sym_documentation_comment, + [94912] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4218), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1833), 2, + sym_comment, + sym_documentation_comment, + [94992] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1834), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1963), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1965), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95036] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1835), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1967), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1969), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95080] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1836), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1921), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1923), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95124] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1837), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1925), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1927), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95168] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(492), 1, + anon_sym_RPAREN, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4220), 1, + anon_sym_LBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(2817), 1, + sym_record_type_field, + STATE(1838), 2, + sym_comment, + sym_documentation_comment, + [95248] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1839), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1995), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1997), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95292] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1840), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1999), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(2001), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95336] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1841), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2003), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(2005), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95380] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1842), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2007), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(2009), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95424] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1843), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1901), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1903), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95468] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1844), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2011), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(2013), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95512] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1845), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2015), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(2017), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95556] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1846), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1905), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1907), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [95600] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2485), 1, + sym_uri, + STATE(2495), 1, + sym_string_literal, + STATE(2498), 1, + sym_configurable_uri, + STATE(1847), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [95666] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4222), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1848), 2, + sym_comment, + sym_documentation_comment, + [95746] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4224), 1, + anon_sym_RBRACK, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(1849), 2, + sym_comment, + sym_documentation_comment, + [95826] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4226), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1850), 2, + sym_comment, + sym_documentation_comment, + [95906] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4228), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1851), 2, + sym_comment, + sym_documentation_comment, + [95986] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4230), 1, + anon_sym_LBRACE, + ACTIONS(4232), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1852), 2, + sym_comment, + sym_documentation_comment, + [96066] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(1938), 1, + sym_nullable_type, + STATE(1853), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4165), 7, + anon_sym_when, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(4167), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [96114] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1854), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1943), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1945), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [96158] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(4234), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2464), 1, + sym__get, + STATE(2465), 1, + sym__set, + STATE(2606), 1, + sym__type, + STATE(1855), 2, + sym_comment, + sym_documentation_comment, + STATE(3182), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [96234] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4236), 1, + anon_sym_RBRACK, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(1856), 2, + sym_comment, + sym_documentation_comment, + [96314] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4238), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1857), 2, + sym_comment, + sym_documentation_comment, + [96394] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1858), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1947), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1949), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [96438] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4240), 1, + anon_sym_LBRACE, + ACTIONS(4242), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2757), 1, + sym_record_type_field, + STATE(2802), 1, + sym__type, + STATE(1859), 2, + sym_comment, + sym_documentation_comment, + [96518] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4244), 1, + anon_sym_LBRACE, + ACTIONS(4246), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1860), 2, + sym_comment, + sym_documentation_comment, + [96598] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4248), 1, + anon_sym_LBRACE, + ACTIONS(4250), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1861), 2, + sym_comment, + sym_documentation_comment, + [96678] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1862), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1951), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1953), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [96722] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1863), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1955), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1957), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [96766] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2485), 1, + sym_uri, + STATE(2488), 1, + sym_configurable_uri, + STATE(2495), 1, + sym_string_literal, + STATE(1864), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [96832] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4252), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1865), 2, + sym_comment, + sym_documentation_comment, + [96912] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2230), 1, + sym_uri, + STATE(2309), 1, + sym_configurable_uri, + STATE(2495), 1, + sym_string_literal, + STATE(1866), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [96978] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4254), 1, + anon_sym_LBRACE, + ACTIONS(4256), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(2837), 1, + sym_record_type_field, + STATE(1867), 2, + sym_comment, + sym_documentation_comment, + [97058] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4258), 1, + anon_sym_LBRACE, + ACTIONS(4260), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1868), 2, + sym_comment, + sym_documentation_comment, + [97138] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4262), 1, + anon_sym_LBRACE, + ACTIONS(4264), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1869), 2, + sym_comment, + sym_documentation_comment, + [97218] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4266), 1, + anon_sym_LBRACE, + ACTIONS(4268), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(2891), 1, + sym_record_type_field, + STATE(1870), 2, + sym_comment, + sym_documentation_comment, + [97298] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4270), 1, + anon_sym_LBRACE, + ACTIONS(4272), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1871), 2, + sym_comment, + sym_documentation_comment, + [97378] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4274), 1, + anon_sym_LBRACE, + ACTIONS(4276), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1872), 2, + sym_comment, + sym_documentation_comment, + [97458] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(4234), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2464), 1, + sym__get, + STATE(2465), 1, + sym__set, + STATE(2606), 1, + sym__type, + STATE(1873), 2, + sym_comment, + sym_documentation_comment, + STATE(3286), 3, + sym_getter_signature, + sym_setter_signature, + sym_function_signature, + [97534] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4278), 1, + anon_sym_LBRACE, + ACTIONS(4280), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(2932), 1, + sym_record_type_field, + STATE(1874), 2, + sym_comment, + sym_documentation_comment, + [97614] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4282), 1, + anon_sym_LBRACE, + ACTIONS(4284), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1875), 2, + sym_comment, + sym_documentation_comment, + [97694] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4286), 1, + anon_sym_LBRACE, + ACTIONS(4288), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1876), 2, + sym_comment, + sym_documentation_comment, + [97774] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4290), 1, + anon_sym_LBRACE, + ACTIONS(4292), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(2955), 1, + sym_record_type_field, + STATE(1877), 2, + sym_comment, + sym_documentation_comment, + [97854] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4294), 1, + anon_sym_LBRACE, + ACTIONS(4296), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1878), 2, + sym_comment, + sym_documentation_comment, + [97934] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4298), 1, + anon_sym_LBRACE, + ACTIONS(4300), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1879), 2, + sym_comment, + sym_documentation_comment, + [98014] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4302), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1880), 2, + sym_comment, + sym_documentation_comment, + [98094] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4304), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1881), 2, + sym_comment, + sym_documentation_comment, + [98174] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4306), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1882), 2, + sym_comment, + sym_documentation_comment, + [98254] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4308), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1883), 2, + sym_comment, + sym_documentation_comment, + [98334] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4310), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1884), 2, + sym_comment, + sym_documentation_comment, + [98414] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4312), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1885), 2, + sym_comment, + sym_documentation_comment, + [98494] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4314), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1886), 2, + sym_comment, + sym_documentation_comment, + [98574] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4316), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1887), 2, + sym_comment, + sym_documentation_comment, + [98654] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4318), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1888), 2, + sym_comment, + sym_documentation_comment, + [98734] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4320), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1889), 2, + sym_comment, + sym_documentation_comment, + [98814] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4322), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1890), 2, + sym_comment, + sym_documentation_comment, + [98894] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4324), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1891), 2, + sym_comment, + sym_documentation_comment, + [98974] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4326), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1892), 2, + sym_comment, + sym_documentation_comment, + [99054] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4328), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1893), 2, + sym_comment, + sym_documentation_comment, + [99134] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4330), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1894), 2, + sym_comment, + sym_documentation_comment, + [99214] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4332), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1895), 2, + sym_comment, + sym_documentation_comment, + [99294] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4334), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1896), 2, + sym_comment, + sym_documentation_comment, + [99374] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1897), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1959), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(1961), 16, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [99418] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4336), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1898), 2, + sym_comment, + sym_documentation_comment, + [99498] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4338), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1899), 2, + sym_comment, + sym_documentation_comment, + [99578] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4340), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1900), 2, + sym_comment, + sym_documentation_comment, + [99658] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4342), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1901), 2, + sym_comment, + sym_documentation_comment, + [99738] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4344), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1902), 2, + sym_comment, + sym_documentation_comment, + [99818] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4346), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1903), 2, + sym_comment, + sym_documentation_comment, + [99898] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4348), 1, + anon_sym_RBRACE, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1904), 2, + sym_comment, + sym_documentation_comment, + [99978] = 26, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4350), 1, + anon_sym_LBRACE, + ACTIONS(4352), 1, + anon_sym_RPAREN, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1905), 2, + sym_comment, + sym_documentation_comment, + [100058] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3035), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1906), 2, + sym_comment, + sym_documentation_comment, + [100135] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3025), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1907), 2, + sym_comment, + sym_documentation_comment, + [100212] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2888), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1908), 2, + sym_comment, + sym_documentation_comment, + [100289] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(1909), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(4354), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [100350] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2764), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(1910), 2, + sym_comment, + sym_documentation_comment, + [100427] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1911), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4361), 8, + anon_sym_when, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2722), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [100470] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2495), 1, + sym_string_literal, + STATE(3148), 1, + sym_uri, + STATE(1912), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [100533] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3147), 1, + sym_typed_identifier, + STATE(3324), 1, + sym_record_type_named_field, + STATE(3422), 1, + sym__type, + STATE(1913), 2, + sym_comment, + sym_documentation_comment, + [100610] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2832), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1914), 2, + sym_comment, + sym_documentation_comment, + [100687] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2048), 1, + sym__metadata, + STATE(2685), 1, + sym__type, + STATE(2738), 1, + sym_normal_parameter_type, + STATE(3029), 1, + sym_typed_identifier, + STATE(1915), 2, + sym_comment, + sym_documentation_comment, + [100764] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1916), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4363), 6, + anon_sym_LT, + anon_sym_GT, + anon_sym_GT_GT, + anon_sym_SLASH, + anon_sym_TILDE, + anon_sym_LBRACK_RBRACK, + ACTIONS(4365), 13, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PIPE, + anon_sym_CARET, + anon_sym_AMP, + anon_sym_LT_LT, + anon_sym_GT_GT_GT, + sym__additive_operator, + anon_sym_STAR, + anon_sym_PERCENT, + anon_sym_TILDE_SLASH, + anon_sym_EQ_EQ, + anon_sym_LBRACK_RBRACK_EQ, + [100807] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2495), 1, + sym_string_literal, + STATE(2579), 1, + sym_uri, + STATE(1917), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [100870] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(3851), 1, + anon_sym_SEMI, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2552), 1, + sym_string_literal, + STATE(1918), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [100933] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(4234), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2465), 1, + sym__set, + STATE(2530), 1, + sym__get, + STATE(2615), 1, + sym__type, + STATE(1919), 2, + sym_comment, + sym_documentation_comment, + STATE(3559), 2, + sym_setter_signature, + sym_function_signature, + [101008] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1920), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4210), 8, + anon_sym_when, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2581), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [101051] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2748), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1921), 2, + sym_comment, + sym_documentation_comment, + [101128] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3032), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1922), 2, + sym_comment, + sym_documentation_comment, + [101205] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(2495), 1, + sym_string_literal, + STATE(3136), 1, + sym_uri, + STATE(1923), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [101268] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2981), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1924), 2, + sym_comment, + sym_documentation_comment, + [101345] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2986), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1925), 2, + sym_comment, + sym_documentation_comment, + [101422] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2989), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1926), 2, + sym_comment, + sym_documentation_comment, + [101499] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(2995), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1927), 2, + sym_comment, + sym_documentation_comment, + [101576] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3004), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1928), 2, + sym_comment, + sym_documentation_comment, + [101653] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3008), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1929), 2, + sym_comment, + sym_documentation_comment, + [101730] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3011), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1930), 2, + sym_comment, + sym_documentation_comment, + [101807] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3015), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1931), 2, + sym_comment, + sym_documentation_comment, + [101884] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3017), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1932), 2, + sym_comment, + sym_documentation_comment, + [101961] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3019), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1933), 2, + sym_comment, + sym_documentation_comment, + [102038] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3023), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1934), 2, + sym_comment, + sym_documentation_comment, + [102115] = 25, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2036), 1, + sym__metadata, + STATE(3027), 1, + sym_record_type_named_field, + STATE(3147), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1935), 2, + sym_comment, + sym_documentation_comment, + [102192] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4369), 1, + anon_sym_QMARK, + ACTIONS(4374), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_LPAREN, + anon_sym_LT, + ACTIONS(4372), 2, + anon_sym_as, + anon_sym_when, + STATE(1936), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4367), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [102244] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4212), 1, + anon_sym_LBRACE, + ACTIONS(4214), 1, + anon_sym_LBRACK, + ACTIONS(4216), 1, + anon_sym_LPAREN, + ACTIONS(4377), 1, + sym_identifier, + STATE(962), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2696), 1, + sym__type_not_void, + STATE(3069), 1, + sym_type_arguments, + STATE(1937), 2, + sym_comment, + sym_documentation_comment, + [102318] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1938), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4379), 7, + anon_sym_when, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(4381), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_GT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [102360] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4377), 1, + sym_identifier, + ACTIONS(4383), 1, + anon_sym_LBRACE, + ACTIONS(4385), 1, + anon_sym_LBRACK, + ACTIONS(4387), 1, + anon_sym_LPAREN, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2443), 1, + sym__record_literal_no_const, + STATE(2634), 1, + sym__type_not_function, + STATE(2646), 1, + sym__type_not_void, + STATE(3246), 1, + sym_type_arguments, + STATE(1939), 2, + sym_comment, + sym_documentation_comment, + [102434] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4389), 1, + anon_sym_LBRACK, + ACTIONS(4391), 1, + anon_sym_QMARK, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4395), 1, + anon_sym_DOT, + ACTIONS(4397), 1, + anon_sym_QMARK_DOT, + STATE(1250), 1, + sym__assignable_selector, + STATE(1304), 1, + sym_index_selector, + STATE(1494), 1, + sym__assignable_selector_part, + STATE(1973), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1305), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1940), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [102504] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4202), 1, + anon_sym_LBRACE, + ACTIONS(4204), 1, + anon_sym_LBRACK, + ACTIONS(4206), 1, + anon_sym_LPAREN, + ACTIONS(4377), 1, + sym_identifier, + STATE(962), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2696), 1, + sym__type_not_void, + STATE(3268), 1, + sym_type_arguments, + STATE(1941), 2, + sym_comment, + sym_documentation_comment, + [102578] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4401), 1, + anon_sym_QMARK, + ACTIONS(4403), 1, + anon_sym_DOT, + ACTIONS(4405), 1, + anon_sym_QMARK_DOT, + STATE(999), 1, + sym_index_selector, + STATE(1025), 1, + sym__assignable_selector, + STATE(1335), 1, + sym__assignable_selector_part, + STATE(1970), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1000), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1942), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [102648] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2015), 1, + sym_inferred_type, + STATE(2021), 1, + sym_final_builtin, + STATE(2744), 1, + sym__type, + STATE(3020), 1, + sym__var_or_type, + STATE(1943), 2, + sym_comment, + sym_documentation_comment, + [102722] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4377), 1, + sym_identifier, + ACTIONS(4407), 1, + anon_sym_LBRACE, + ACTIONS(4409), 1, + anon_sym_LBRACK, + ACTIONS(4411), 1, + anon_sym_LPAREN, + STATE(1261), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2635), 1, + sym__type_not_void, + STATE(3271), 1, + sym_type_arguments, + STATE(1944), 2, + sym_comment, + sym_documentation_comment, + [102796] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2005), 1, + sym_final_builtin, + STATE(2015), 1, + sym_inferred_type, + STATE(2730), 1, + sym__var_or_type, + STATE(2744), 1, + sym__type, + STATE(1945), 2, + sym_comment, + sym_documentation_comment, + [102870] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4401), 1, + anon_sym_QMARK, + ACTIONS(4403), 1, + anon_sym_DOT, + ACTIONS(4405), 1, + anon_sym_QMARK_DOT, + STATE(927), 1, + sym__assignable_selector_part, + STATE(969), 1, + sym__assignable_selector, + STATE(999), 1, + sym_index_selector, + STATE(1952), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1000), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1946), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [102940] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(83), 1, + anon_sym_DQUOTE, + ACTIONS(85), 1, + anon_sym_SQUOTE, + ACTIONS(87), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(89), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(91), 1, + anon_sym_r_DQUOTE, + ACTIONS(93), 1, + anon_sym_r_SQUOTE, + ACTIONS(95), 1, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(97), 1, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + STATE(478), 1, + aux_sym_string_literal_repeat1, + STATE(3578), 1, + sym_string_literal, + STATE(1947), 2, + sym_comment, + sym_documentation_comment, + STATE(622), 8, + sym__string_literal_double_quotes, + sym__string_literal_single_quotes, + sym__string_literal_double_quotes_multiple, + sym__string_literal_single_quotes_multiple, + sym__raw_string_literal_double_quotes, + sym__raw_string_literal_single_quotes, + sym__raw_string_literal_double_quotes_multiple, + sym__raw_string_literal_single_quotes_multiple, + [103000] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2122), 1, + sym__metadata, + STATE(2802), 1, + sym__type, + STATE(3204), 1, + sym_record_type_field, + STATE(1948), 2, + sym_comment, + sym_documentation_comment, + [103074] = 24, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4377), 1, + sym_identifier, + ACTIONS(4413), 1, + anon_sym_LBRACE, + ACTIONS(4415), 1, + anon_sym_LBRACK, + ACTIONS(4417), 1, + anon_sym_LPAREN, + STATE(1151), 1, + sym__record_literal_no_const, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2639), 1, + sym__type_not_void, + STATE(3284), 1, + sym_type_arguments, + STATE(1949), 2, + sym_comment, + sym_documentation_comment, + [103148] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4421), 1, + anon_sym_QMARK, + ACTIONS(4423), 1, + anon_sym_DOT, + ACTIONS(4425), 1, + anon_sym_QMARK_DOT, + STATE(1161), 1, + sym__assignable_selector, + STATE(1169), 1, + sym_index_selector, + STATE(1414), 1, + sym__assignable_selector_part, + STATE(1956), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1090), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1950), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [103218] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4421), 1, + anon_sym_QMARK, + ACTIONS(4423), 1, + anon_sym_DOT, + ACTIONS(4425), 1, + anon_sym_QMARK_DOT, + STATE(1140), 1, + sym__assignable_selector_part, + STATE(1169), 1, + sym_index_selector, + STATE(1171), 1, + sym__assignable_selector, + STATE(1960), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1090), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1951), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [103288] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4401), 1, + anon_sym_QMARK, + ACTIONS(4403), 1, + anon_sym_DOT, + ACTIONS(4405), 1, + anon_sym_QMARK_DOT, + STATE(971), 1, + sym__assignable_selector, + STATE(999), 1, + sym_index_selector, + STATE(1978), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1000), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1952), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [103355] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4377), 1, + sym_identifier, + ACTIONS(4427), 1, + anon_sym_LBRACE, + ACTIONS(4429), 1, + anon_sym_LBRACK, + ACTIONS(4431), 1, + anon_sym_LPAREN, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2674), 1, + sym__type_not_void, + STATE(3213), 1, + sym_type_arguments, + STATE(1953), 2, + sym_comment, + sym_documentation_comment, + [103426] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4433), 1, + sym_increment_operator, + STATE(275), 1, + sym__assignment_operator, + STATE(1507), 1, + sym_postfix_operator, + STATE(1954), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103471] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1955), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1738), 3, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4435), 14, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_static, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [103512] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4421), 1, + anon_sym_QMARK, + ACTIONS(4423), 1, + anon_sym_DOT, + ACTIONS(4425), 1, + anon_sym_QMARK_DOT, + STATE(1163), 1, + sym__assignable_selector, + STATE(1169), 1, + sym_index_selector, + STATE(1978), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1090), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1956), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [103579] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(304), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1957), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103624] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4439), 1, + sym_increment_operator, + STATE(229), 1, + sym__assignment_operator, + STATE(1114), 1, + sym_postfix_operator, + STATE(1958), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103669] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(216), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1959), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103714] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4421), 1, + anon_sym_QMARK, + ACTIONS(4423), 1, + anon_sym_DOT, + ACTIONS(4425), 1, + anon_sym_QMARK_DOT, + STATE(1169), 1, + sym_index_selector, + STATE(1175), 1, + sym__assignable_selector, + STATE(1978), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1090), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1960), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [103781] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4441), 1, + sym_increment_operator, + STATE(297), 1, + sym__assignment_operator, + STATE(1392), 1, + sym_postfix_operator, + STATE(1961), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103826] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2083), 1, + sym__metadata, + STATE(3351), 1, + sym__type, + STATE(1962), 2, + sym_comment, + sym_documentation_comment, + [103897] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4441), 1, + sym_increment_operator, + STATE(279), 1, + sym__assignment_operator, + STATE(1392), 1, + sym_postfix_operator, + STATE(1963), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103942] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4439), 1, + sym_increment_operator, + STATE(282), 1, + sym__assignment_operator, + STATE(1114), 1, + sym_postfix_operator, + STATE(1964), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [103987] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4433), 1, + sym_increment_operator, + STATE(307), 1, + sym__assignment_operator, + STATE(1507), 1, + sym_postfix_operator, + STATE(1965), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [104032] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1966), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1792), 3, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4443), 14, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_static, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [104073] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2079), 1, + sym_final_builtin, + STATE(1967), 2, + sym_comment, + sym_documentation_comment, + STATE(2836), 2, + sym__type, + sym_inferred_type, + [104142] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2022), 1, + sym_final_builtin, + STATE(1968), 2, + sym_comment, + sym_documentation_comment, + STATE(2836), 2, + sym__type, + sym_inferred_type, + [104211] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4445), 1, + sym_increment_operator, + STATE(204), 1, + sym__assignment_operator, + STATE(1319), 1, + sym_postfix_operator, + STATE(1969), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [104256] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4401), 1, + anon_sym_QMARK, + ACTIONS(4403), 1, + anon_sym_DOT, + ACTIONS(4405), 1, + anon_sym_QMARK_DOT, + STATE(999), 1, + sym_index_selector, + STATE(1016), 1, + sym__assignable_selector, + STATE(1978), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1000), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1970), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [104323] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1971), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4449), 3, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4447), 14, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_static, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [104364] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(67), 1, + anon_sym_late, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(1967), 1, + sym__late_builtin, + STATE(1972), 2, + sym_comment, + sym_documentation_comment, + STATE(3020), 2, + sym__type, + sym_inferred_type, + [104433] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4389), 1, + anon_sym_LBRACK, + ACTIONS(4391), 1, + anon_sym_QMARK, + ACTIONS(4393), 1, + anon_sym_LT, + ACTIONS(4395), 1, + anon_sym_DOT, + ACTIONS(4397), 1, + anon_sym_QMARK_DOT, + STATE(1267), 1, + sym__assignable_selector, + STATE(1304), 1, + sym_index_selector, + STATE(1978), 1, + aux_sym__assignable_selector_part_repeat1, + STATE(2351), 1, + sym_type_arguments, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(1305), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1973), 2, + sym_comment, + sym_documentation_comment, + STATE(2438), 2, + sym__exclamation_operator, + sym_argument_part, + [104500] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(308), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1974), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [104545] = 23, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2097), 1, + sym__metadata, + STATE(3615), 1, + sym__type, + STATE(1975), 2, + sym_comment, + sym_documentation_comment, + [104616] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2008), 1, + sym_final_builtin, + STATE(1976), 2, + sym_comment, + sym_documentation_comment, + STATE(2740), 2, + sym__type, + sym_inferred_type, + [104685] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(221), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1977), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [104730] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4451), 1, + anon_sym_LBRACK, + ACTIONS(4454), 1, + anon_sym_LPAREN, + ACTIONS(4457), 1, + anon_sym_QMARK, + ACTIONS(4460), 1, + anon_sym_LT, + ACTIONS(4463), 1, + anon_sym_BANG, + ACTIONS(4466), 1, + anon_sym_DOT, + ACTIONS(4469), 1, + anon_sym_QMARK_DOT, + STATE(2351), 1, + sym_type_arguments, + STATE(2368), 1, + sym_index_selector, + STATE(2435), 1, + sym_selector, + STATE(2440), 1, + sym_arguments, + STATE(2369), 2, + sym_unconditional_assignable_selector, + sym_conditional_assignable_selector, + STATE(1978), 3, + sym_comment, + sym_documentation_comment, + aux_sym__assignable_selector_part_repeat1, + STATE(2438), 3, + sym__exclamation_operator, + sym_argument_part, + sym__assignable_selector, + [104793] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(35), 1, + anon_sym_var, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(145), 1, + anon_sym_final, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2017), 1, + sym_final_builtin, + STATE(1979), 2, + sym_comment, + sym_documentation_comment, + STATE(2839), 2, + sym__type, + sym_inferred_type, + [104862] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1980), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4474), 3, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_AT, + ACTIONS(4472), 14, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_static, + sym_const_builtin, + anon_sym_late, + anon_sym_external, + sym_identifier, + [104903] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2348), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + STATE(1981), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4476), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [104962] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(287), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1982), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [105007] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4445), 1, + sym_increment_operator, + STATE(299), 1, + sym__assignment_operator, + STATE(1319), 1, + sym_postfix_operator, + STATE(1983), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [105052] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(225), 1, + sym__assignment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(1984), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1131), 14, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + [105097] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1985), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2956), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2954), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105137] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1986), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2840), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2838), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105177] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1987), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2920), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(2918), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105217] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1988), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1133), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1127), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105257] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(450), 1, + anon_sym_required, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2059), 1, + sym__required, + STATE(3200), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(1989), 2, + sym_comment, + sym_documentation_comment, + [105325] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1990), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1157), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1155), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105365] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1991), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3044), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3042), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105405] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1992), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1399), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(1397), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105445] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3308), 1, + sym__type, + STATE(3570), 1, + sym_getter_signature, + STATE(3612), 1, + sym__get, + STATE(1993), 2, + sym_comment, + sym_documentation_comment, + [105513] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1994), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3112), 4, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + anon_sym_async, + ACTIONS(3110), 12, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [105553] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1995), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1963), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1965), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105592] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1996), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1999), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(2001), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105631] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1997), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2003), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(2005), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105670] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1998), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2007), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(2009), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105709] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1999), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1951), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1953), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105748] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2000), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2011), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(2013), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105787] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2001), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2015), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(2017), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105826] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2002), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1905), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1907), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105865] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2095), 1, + sym_nullable_type, + STATE(2003), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 3, + anon_sym_catch, + anon_sym_with, + anon_sym_implements, + ACTIONS(4210), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2574), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + [105910] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2004), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1955), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1957), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [105949] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4478), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3000), 1, + sym__type, + ACTIONS(4481), 2, + anon_sym_this, + anon_sym_super, + STATE(2005), 2, + sym_comment, + sym_documentation_comment, + [106012] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2006), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1959), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1961), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [106051] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2007), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1947), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1949), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [106090] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4483), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2839), 1, + sym__type, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3182), 1, + sym_initialized_identifier_list, + STATE(2008), 2, + sym_comment, + sym_documentation_comment, + [106155] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3954), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2730), 1, + sym__type, + ACTIONS(4208), 2, + anon_sym_this, + anon_sym_super, + STATE(2009), 2, + sym_comment, + sym_documentation_comment, + [106218] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4483), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3020), 1, + sym__type, + STATE(3559), 1, + sym_initialized_identifier_list, + STATE(2010), 2, + sym_comment, + sym_documentation_comment, + [106283] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2011), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1696), 15, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_TILDE_SLASH_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_GT_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_CARET_EQ, + anon_sym_PIPE_EQ, + anon_sym_QMARK_QMARK_EQ, + sym_increment_operator, + [106320] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2012), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1967), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1969), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [106359] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2013), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1921), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1923), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [106398] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4485), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2742), 1, + sym__type, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + STATE(2014), 2, + sym_comment, + sym_documentation_comment, + [106461] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3895), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2742), 1, + sym__type, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + STATE(2015), 2, + sym_comment, + sym_documentation_comment, + [106524] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2316), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(4491), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2016), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [106581] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4483), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2905), 1, + sym__type, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3062), 1, + sym_initialized_identifier_list, + STATE(2017), 2, + sym_comment, + sym_documentation_comment, + [106646] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4494), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2771), 1, + sym__type, + STATE(2826), 1, + sym_static_final_declaration, + STATE(3182), 1, + sym_static_final_declaration_list, + STATE(2018), 2, + sym_comment, + sym_documentation_comment, + [106711] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4494), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2826), 1, + sym_static_final_declaration, + STATE(2850), 1, + sym__type, + STATE(3570), 1, + sym_static_final_declaration_list, + STATE(2019), 2, + sym_comment, + sym_documentation_comment, + [106776] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2020), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1925), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1927), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [106815] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4483), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2836), 1, + sym__type, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3570), 1, + sym_initialized_identifier_list, + STATE(2021), 2, + sym_comment, + sym_documentation_comment, + [106880] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4483), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2739), 1, + sym__type, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3369), 1, + sym_initialized_identifier_list, + STATE(2022), 2, + sym_comment, + sym_documentation_comment, + [106945] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4496), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3040), 1, + sym__type, + ACTIONS(4208), 2, + anon_sym_this, + anon_sym_super, + STATE(2023), 2, + sym_comment, + sym_documentation_comment, + [107008] = 21, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4494), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2826), 1, + sym_static_final_declaration, + STATE(2861), 1, + sym__type, + STATE(3286), 1, + sym_static_final_declaration_list, + STATE(2024), 2, + sym_comment, + sym_documentation_comment, + [107073] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2025), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1995), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1997), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [107112] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2026), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1943), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1945), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [107151] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2027), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1901), 5, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + anon_sym_QMARK, + ACTIONS(1903), 10, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [107190] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(1941), 1, + anon_sym_GT, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2913), 1, + sym__type, + STATE(2028), 2, + sym_comment, + sym_documentation_comment, + [107252] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4502), 1, + anon_sym_EQ, + STATE(2029), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4500), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [107290] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4506), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2030), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4504), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [107328] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3200), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(2031), 2, + sym_comment, + sym_documentation_comment, + [107390] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4510), 1, + anon_sym_EQ, + STATE(2032), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4508), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [107428] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4512), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2853), 1, + sym__type, + STATE(2033), 2, + sym_comment, + sym_documentation_comment, + [107490] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4516), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2034), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4514), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [107528] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4374), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2035), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4518), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [107568] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3120), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(2036), 2, + sym_comment, + sym_documentation_comment, + [107630] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + ACTIONS(4522), 1, + anon_sym_DOT, + STATE(1730), 1, + sym_nullable_type, + STATE(2128), 1, + sym_type_arguments, + ACTIONS(2485), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2037), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 6, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + [107680] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4526), 1, + anon_sym_EQ, + STATE(2038), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4524), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [107718] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2578), 1, + sym__type_not_void, + STATE(2622), 1, + sym__type_not_void_list, + STATE(2658), 1, + sym__type_not_function, + STATE(2039), 2, + sym_comment, + sym_documentation_comment, + [107780] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4530), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2040), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4528), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [107818] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2578), 1, + sym__type_not_void, + STATE(2658), 1, + sym__type_not_function, + STATE(3013), 1, + sym__type_not_void_list, + STATE(2041), 2, + sym_comment, + sym_documentation_comment, + [107880] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4532), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2900), 1, + sym__type, + STATE(2042), 2, + sym_comment, + sym_documentation_comment, + [107942] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4536), 1, + anon_sym_EQ, + STATE(2043), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4534), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [107980] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4540), 1, + anon_sym_EQ, + STATE(2044), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4538), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108018] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4544), 1, + anon_sym_EQ, + STATE(2045), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4542), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108056] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4548), 1, + anon_sym_EQ, + STATE(2046), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4546), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108094] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2630), 1, + anon_sym_EQ, + STATE(2047), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4550), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108132] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2688), 1, + sym__type, + STATE(2770), 1, + sym_typed_identifier, + STATE(2048), 2, + sym_comment, + sym_documentation_comment, + [108194] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2578), 1, + sym__type_not_void, + STATE(2658), 1, + sym__type_not_function, + STATE(3292), 1, + sym__type_not_void_list, + STATE(2049), 2, + sym_comment, + sym_documentation_comment, + [108256] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4552), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2943), 1, + sym__type, + STATE(2050), 2, + sym_comment, + sym_documentation_comment, + [108318] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4556), 1, + anon_sym_EQ, + STATE(2051), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4554), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108356] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3274), 1, + sym__type_not_void, + STATE(3313), 1, + sym_mixin_application, + STATE(2052), 2, + sym_comment, + sym_documentation_comment, + [108418] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1004), 1, + anon_sym_EQ, + STATE(2053), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4558), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108456] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4560), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2959), 1, + sym__type, + STATE(2054), 2, + sym_comment, + sym_documentation_comment, + [108518] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4564), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2055), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4562), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [108556] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2814), 1, + anon_sym_EQ, + STATE(2056), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4566), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108594] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2578), 1, + sym__type_not_void, + STATE(2609), 1, + sym__type_not_void_list, + STATE(2658), 1, + sym__type_not_function, + STATE(2057), 2, + sym_comment, + sym_documentation_comment, + [108656] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4568), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2968), 1, + sym__type, + STATE(2058), 2, + sym_comment, + sym_documentation_comment, + [108718] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3217), 1, + sym_typed_identifier, + STATE(3422), 1, + sym__type, + STATE(2059), 2, + sym_comment, + sym_documentation_comment, + [108780] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4570), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2972), 1, + sym__type, + STATE(2060), 2, + sym_comment, + sym_documentation_comment, + [108842] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4574), 1, + anon_sym_EQ, + STATE(2061), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4572), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108880] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4578), 1, + anon_sym_EQ, + STATE(2062), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4576), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108918] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4582), 1, + anon_sym_EQ, + STATE(2063), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4580), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [108956] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + ACTIONS(4584), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2300), 1, + sym__formal_parameter_part, + STATE(2354), 1, + sym_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(2064), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 5, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + sym_identifier, + [109010] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + ACTIONS(4586), 1, + anon_sym_GT, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2776), 1, + sym__type, + STATE(2065), 2, + sym_comment, + sym_documentation_comment, + [109072] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4590), 1, + anon_sym_EQ, + STATE(2066), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4588), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109110] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2578), 1, + sym__type_not_void, + STATE(2601), 1, + sym__type_not_void_list, + STATE(2658), 1, + sym__type_not_function, + STATE(2067), 2, + sym_comment, + sym_documentation_comment, + [109172] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1468), 1, + anon_sym_COLON, + ACTIONS(4369), 1, + anon_sym_QMARK, + ACTIONS(4374), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_LPAREN, + anon_sym_LT, + ACTIONS(4372), 2, + anon_sym_as, + anon_sym_when, + STATE(2068), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4367), 4, + anon_sym_BANG, + anon_sym_EQ_GT, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109222] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2624), 1, + anon_sym_EQ, + STATE(2069), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4592), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109260] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4596), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2070), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4594), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [109298] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4600), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2071), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4598), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [109336] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4604), 1, + anon_sym_EQ, + STATE(2072), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4602), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109374] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4516), 1, + anon_sym_async, + STATE(2073), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2674), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_QMARK, + ACTIONS(4514), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + ACTIONS(2676), 6, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + [109416] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2568), 1, + sym__type_not_void_list, + STATE(2578), 1, + sym__type_not_void, + STATE(2658), 1, + sym__type_not_function, + STATE(2074), 2, + sym_comment, + sym_documentation_comment, + [109478] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3272), 1, + sym_mixin_application, + STATE(3274), 1, + sym__type_not_void, + STATE(2075), 2, + sym_comment, + sym_documentation_comment, + [109540] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4608), 1, + anon_sym_EQ, + STATE(2076), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4606), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_in, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109578] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4612), 2, + anon_sym_EQ, + anon_sym_async, + STATE(2077), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4610), 12, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [109616] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4372), 1, + anon_sym_as, + ACTIONS(4374), 1, + anon_sym_DOT, + ACTIONS(4614), 1, + anon_sym_COLON, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_LPAREN, + anon_sym_LT, + STATE(2078), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4367), 3, + anon_sym_BANG, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + ACTIONS(4369), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_QMARK, + [109666] = 20, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4616), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3215), 1, + sym__type, + STATE(3369), 1, + sym_identifier_list, + STATE(2079), 2, + sym_comment, + sym_documentation_comment, + [109728] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4369), 1, + anon_sym_QMARK, + ACTIONS(4372), 1, + anon_sym_as, + ACTIONS(4374), 1, + anon_sym_DOT, + ACTIONS(4614), 1, + anon_sym_COLON, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_LPAREN, + anon_sym_LT, + STATE(2080), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4367), 5, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [109778] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2644), 1, + sym__type_not_void, + STATE(2081), 2, + sym_comment, + sym_documentation_comment, + [109837] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3197), 1, + sym__type, + STATE(2082), 2, + sym_comment, + sym_documentation_comment, + [109896] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3608), 1, + sym__type, + STATE(2083), 2, + sym_comment, + sym_documentation_comment, + [109955] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3055), 1, + sym__type_not_void, + STATE(2084), 2, + sym_comment, + sym_documentation_comment, + [110014] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3149), 1, + sym__type, + STATE(2085), 2, + sym_comment, + sym_documentation_comment, + [110073] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(2686), 1, + sym__type_not_void, + STATE(2086), 2, + sym_comment, + sym_documentation_comment, + [110132] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4618), 1, + sym_identifier, + ACTIONS(4620), 1, + anon_sym_LPAREN, + ACTIONS(4622), 1, + anon_sym_Function, + STATE(756), 1, + aux_sym__function_type_tails, + STATE(757), 1, + sym__function_builtin_identifier, + STATE(788), 1, + sym__type_name, + STATE(822), 1, + sym_record_type, + STATE(836), 1, + sym__function_type_tail, + STATE(868), 1, + sym__type_not_void_not_function, + STATE(869), 1, + sym_function_type, + STATE(944), 1, + sym__type_not_void, + STATE(2628), 1, + sym__type_not_function, + STATE(2087), 2, + sym_comment, + sym_documentation_comment, + [110191] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4618), 1, + sym_identifier, + ACTIONS(4620), 1, + anon_sym_LPAREN, + ACTIONS(4622), 1, + anon_sym_Function, + STATE(756), 1, + aux_sym__function_type_tails, + STATE(757), 1, + sym__function_builtin_identifier, + STATE(788), 1, + sym__type_name, + STATE(822), 1, + sym_record_type, + STATE(836), 1, + sym__function_type_tail, + STATE(868), 1, + sym__type_not_void_not_function, + STATE(869), 1, + sym_function_type, + STATE(949), 1, + sym__type_not_void, + STATE(2628), 1, + sym__type_not_function, + STATE(2088), 2, + sym_comment, + sym_documentation_comment, + [110250] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3469), 1, + sym__type, + STATE(2089), 2, + sym_comment, + sym_documentation_comment, + [110309] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2090), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2579), 3, + anon_sym_catch, + anon_sym_with, + anon_sym_implements, + ACTIONS(4210), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2574), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + [110348] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4624), 1, + sym_identifier, + ACTIONS(4626), 1, + anon_sym_LPAREN, + ACTIONS(4628), 1, + anon_sym_Function, + STATE(1341), 1, + sym__function_builtin_identifier, + STATE(1381), 1, + aux_sym__function_type_tails, + STATE(1431), 1, + sym__type_name, + STATE(1510), 1, + sym_record_type, + STATE(1519), 1, + sym__type_not_void_not_function, + STATE(1521), 1, + sym_function_type, + STATE(1551), 1, + sym__function_type_tail, + STATE(1584), 1, + sym__type_not_void, + STATE(2684), 1, + sym__type_not_function, + STATE(2091), 2, + sym_comment, + sym_documentation_comment, + [110407] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4624), 1, + sym_identifier, + ACTIONS(4626), 1, + anon_sym_LPAREN, + ACTIONS(4628), 1, + anon_sym_Function, + STATE(1341), 1, + sym__function_builtin_identifier, + STATE(1381), 1, + aux_sym__function_type_tails, + STATE(1431), 1, + sym__type_name, + STATE(1510), 1, + sym_record_type, + STATE(1519), 1, + sym__type_not_void_not_function, + STATE(1521), 1, + sym_function_type, + STATE(1551), 1, + sym__function_type_tail, + STATE(1604), 1, + sym__type_not_void, + STATE(2684), 1, + sym__type_not_function, + STATE(2092), 2, + sym_comment, + sym_documentation_comment, + [110466] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3245), 1, + sym__type_not_void, + STATE(2093), 2, + sym_comment, + sym_documentation_comment, + [110525] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(2682), 1, + sym__type_not_void, + STATE(2094), 2, + sym_comment, + sym_documentation_comment, + [110584] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2095), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2720), 3, + anon_sym_catch, + anon_sym_with, + anon_sym_implements, + ACTIONS(4361), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2718), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + [110623] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3134), 1, + sym__type_not_void, + STATE(2096), 2, + sym_comment, + sym_documentation_comment, + [110682] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3473), 1, + sym__type, + STATE(2097), 2, + sym_comment, + sym_documentation_comment, + [110741] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3085), 1, + sym__type, + STATE(2098), 2, + sym_comment, + sym_documentation_comment, + [110800] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2142), 1, + sym__type_name, + STATE(3064), 1, + sym__type, + STATE(2099), 2, + sym_comment, + sym_documentation_comment, + [110859] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4630), 1, + sym_identifier, + ACTIONS(4632), 1, + anon_sym_LPAREN, + ACTIONS(4634), 1, + anon_sym_Function, + STATE(888), 1, + aux_sym__function_type_tails, + STATE(891), 1, + sym__function_builtin_identifier, + STATE(960), 1, + sym__type_name, + STATE(1007), 1, + sym_record_type, + STATE(1062), 1, + sym__function_type_tail, + STATE(1084), 1, + sym__type_not_void_not_function, + STATE(1086), 1, + sym_function_type, + STATE(1121), 1, + sym__type_not_void, + STATE(2650), 1, + sym__type_not_function, + STATE(2100), 2, + sym_comment, + sym_documentation_comment, + [110918] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3278), 1, + sym__type, + STATE(2101), 2, + sym_comment, + sym_documentation_comment, + [110977] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4636), 1, + sym_identifier, + ACTIONS(4638), 1, + anon_sym_LPAREN, + ACTIONS(4640), 1, + anon_sym_Function, + STATE(1244), 1, + sym__function_builtin_identifier, + STATE(1328), 1, + aux_sym__function_type_tails, + STATE(1344), 1, + sym__type_name, + STATE(1379), 1, + sym_record_type, + STATE(1426), 1, + sym__type_not_void_not_function, + STATE(1427), 1, + sym_function_type, + STATE(1440), 1, + sym__function_type_tail, + STATE(1496), 1, + sym__type_not_void, + STATE(2692), 1, + sym__type_not_function, + STATE(2102), 2, + sym_comment, + sym_documentation_comment, + [111036] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(2672), 1, + sym__type_not_void, + STATE(2103), 2, + sym_comment, + sym_documentation_comment, + [111095] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2656), 1, + sym__type_not_void, + STATE(2104), 2, + sym_comment, + sym_documentation_comment, + [111154] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3190), 1, + sym__type, + STATE(2105), 2, + sym_comment, + sym_documentation_comment, + [111213] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4642), 1, + sym_identifier, + ACTIONS(4644), 1, + anon_sym_LPAREN, + ACTIONS(4646), 1, + anon_sym_Function, + STATE(1435), 1, + sym__function_builtin_identifier, + STATE(1483), 1, + aux_sym__function_type_tails, + STATE(1549), 1, + sym__type_name, + STATE(1600), 1, + sym_record_type, + STATE(1633), 1, + sym__type_not_void_not_function, + STATE(1635), 1, + sym__function_type_tail, + STATE(1652), 1, + sym_function_type, + STATE(1726), 1, + sym__type_not_void, + STATE(2662), 1, + sym__type_not_function, + STATE(2106), 2, + sym_comment, + sym_documentation_comment, + [111272] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2680), 1, + sym__type_not_void, + STATE(2107), 2, + sym_comment, + sym_documentation_comment, + [111331] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4642), 1, + sym_identifier, + ACTIONS(4644), 1, + anon_sym_LPAREN, + ACTIONS(4646), 1, + anon_sym_Function, + STATE(1435), 1, + sym__function_builtin_identifier, + STATE(1483), 1, + aux_sym__function_type_tails, + STATE(1549), 1, + sym__type_name, + STATE(1600), 1, + sym_record_type, + STATE(1633), 1, + sym__type_not_void_not_function, + STATE(1635), 1, + sym__function_type_tail, + STATE(1652), 1, + sym_function_type, + STATE(1680), 1, + sym__type_not_void, + STATE(2662), 1, + sym__type_not_function, + STATE(2108), 2, + sym_comment, + sym_documentation_comment, + [111390] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3102), 1, + sym__type, + STATE(2109), 2, + sym_comment, + sym_documentation_comment, + [111449] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 1, + sym_cascade_section, + ACTIONS(4648), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2110), 3, + sym_comment, + sym_documentation_comment, + aux_sym__expression_repeat1, + ACTIONS(2567), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [111488] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2169), 1, + sym__function_builtin_identifier, + STATE(2187), 1, + aux_sym__function_type_tails, + STATE(2634), 1, + sym__type_not_function, + STATE(2679), 1, + sym__type_not_void, + STATE(2111), 2, + sym_comment, + sym_documentation_comment, + [111547] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3389), 1, + sym__type, + STATE(2112), 2, + sym_comment, + sym_documentation_comment, + [111606] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3432), 1, + sym__type, + STATE(2113), 2, + sym_comment, + sym_documentation_comment, + [111665] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3056), 1, + sym__type, + STATE(2114), 2, + sym_comment, + sym_documentation_comment, + [111724] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 1, + sym_cascade_section, + STATE(2110), 1, + aux_sym__expression_repeat1, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2115), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2593), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_case, + anon_sym_else, + [111765] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3072), 1, + sym__type, + STATE(2116), 2, + sym_comment, + sym_documentation_comment, + [111824] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2228), 1, + sym__type, + STATE(2117), 2, + sym_comment, + sym_documentation_comment, + [111883] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4651), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3436), 1, + sym__type, + STATE(2118), 2, + sym_comment, + sym_documentation_comment, + [111942] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(2977), 1, + sym__formal_parameter_part, + STATE(2119), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + sym_identifier, + [111995] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(4377), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2003), 1, + sym_record_type, + STATE(2090), 1, + sym__type_not_void_not_function, + STATE(2165), 1, + sym_function_type, + STATE(2658), 1, + sym__type_not_function, + STATE(3165), 1, + sym__type_not_void, + STATE(2120), 2, + sym_comment, + sym_documentation_comment, + [112054] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2141), 1, + sym__type_name, + STATE(3299), 1, + sym__type, + STATE(2121), 2, + sym_comment, + sym_documentation_comment, + [112113] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(2908), 1, + sym__type, + STATE(2122), 2, + sym_comment, + sym_documentation_comment, + [112172] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2044), 1, + anon_sym_QMARK, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4358), 1, + anon_sym_LT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2300), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2123), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + sym_identifier, + [112225] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(17), 1, + anon_sym_LPAREN, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(45), 1, + anon_sym_Function, + ACTIONS(3439), 1, + sym_identifier, + STATE(1502), 1, + sym__function_builtin_identifier, + STATE(1530), 1, + sym__type_name, + STATE(1605), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(1816), 1, + sym__type_not_function, + STATE(1830), 1, + sym_record_type, + STATE(1853), 1, + sym_function_type, + STATE(1920), 1, + sym__type_not_void_not_function, + STATE(3071), 1, + sym__type, + STATE(2124), 2, + sym_comment, + sym_documentation_comment, + [112284] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2125), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4518), 13, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112319] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4636), 1, + sym_identifier, + ACTIONS(4638), 1, + anon_sym_LPAREN, + ACTIONS(4640), 1, + anon_sym_Function, + STATE(1244), 1, + sym__function_builtin_identifier, + STATE(1328), 1, + aux_sym__function_type_tails, + STATE(1344), 1, + sym__type_name, + STATE(1379), 1, + sym_record_type, + STATE(1426), 1, + sym__type_not_void_not_function, + STATE(1427), 1, + sym_function_type, + STATE(1440), 1, + sym__function_type_tail, + STATE(1495), 1, + sym__type_not_void, + STATE(2692), 1, + sym__type_not_function, + STATE(2126), 2, + sym_comment, + sym_documentation_comment, + [112378] = 19, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(33), 1, + sym_void_type, + ACTIONS(4630), 1, + sym_identifier, + ACTIONS(4632), 1, + anon_sym_LPAREN, + ACTIONS(4634), 1, + anon_sym_Function, + STATE(888), 1, + aux_sym__function_type_tails, + STATE(891), 1, + sym__function_builtin_identifier, + STATE(960), 1, + sym__type_name, + STATE(1007), 1, + sym_record_type, + STATE(1062), 1, + sym__function_type_tail, + STATE(1084), 1, + sym__type_not_void_not_function, + STATE(1086), 1, + sym_function_type, + STATE(1122), 1, + sym__type_not_void, + STATE(2650), 1, + sym__type_not_function, + STATE(2127), 2, + sym_comment, + sym_documentation_comment, + [112437] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4654), 1, + anon_sym_LPAREN, + ACTIONS(4656), 1, + anon_sym_DOT, + STATE(1736), 1, + sym_nullable_type, + ACTIONS(2586), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2128), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2591), 6, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + anon_sym_this, + anon_sym_super, + sym_identifier, + [112481] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2129), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4658), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112515] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2130), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4660), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112549] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4664), 1, + anon_sym_EQ, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1801), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2201), 1, + sym_type_parameters, + STATE(2564), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3078), 1, + sym_interfaces, + STATE(2131), 2, + sym_comment, + sym_documentation_comment, + [112605] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2132), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4672), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112639] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2133), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3086), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112673] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2134), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3090), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112707] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2135), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3094), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112741] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2136), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3102), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112775] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2534), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2137), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4674), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [112821] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2536), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2138), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4676), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [112867] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2139), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3078), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112901] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2140), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3098), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [112935] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(111), 1, + anon_sym_LT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4678), 1, + anon_sym_EQ, + STATE(1645), 1, + sym_type_arguments, + STATE(1730), 1, + sym_nullable_type, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2670), 1, + sym_type_parameters, + STATE(3572), 1, + sym__formal_parameter_part, + ACTIONS(2493), 2, + anon_sym_Function, + sym_identifier, + STATE(2141), 2, + sym_comment, + sym_documentation_comment, + [112989] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(111), 1, + anon_sym_LT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4680), 1, + anon_sym_EQ, + STATE(1645), 1, + sym_type_arguments, + STATE(1730), 1, + sym_nullable_type, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2643), 1, + sym_type_parameters, + STATE(3432), 1, + sym__formal_parameter_part, + ACTIONS(2493), 2, + anon_sym_Function, + sym_identifier, + STATE(2142), 2, + sym_comment, + sym_documentation_comment, + [113043] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2143), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4682), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113077] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4686), 1, + anon_sym_QMARK, + ACTIONS(4688), 1, + anon_sym_BANG, + ACTIONS(4690), 1, + anon_sym_as, + STATE(2144), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4684), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113117] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2145), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2906), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113151] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2146), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4692), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113185] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2147), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4694), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113219] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2148), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4696), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113253] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2149), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1889), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113287] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2150), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4698), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113321] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2151), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3082), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113355] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2152), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4700), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113389] = 18, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4664), 1, + anon_sym_EQ, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1787), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2207), 1, + sym_type_parameters, + STATE(2586), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3083), 1, + sym_interfaces, + STATE(2153), 2, + sym_comment, + sym_documentation_comment, + [113445] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + ACTIONS(4702), 1, + anon_sym_DOT, + STATE(1730), 1, + sym_nullable_type, + STATE(2128), 1, + sym_type_arguments, + ACTIONS(2485), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2154), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2493), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [113493] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2155), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4367), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113527] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2156), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2830), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113561] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2157), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1893), 12, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [113595] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4706), 2, + anon_sym_LPAREN, + anon_sym_AT, + STATE(2158), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4704), 10, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_covariant, + anon_sym_Function, + sym_const_builtin, + anon_sym_late, + anon_sym_this, + anon_sym_super, + sym_identifier, + [113631] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2524), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2159), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4708), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [113677] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2550), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2160), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4710), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [113723] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2429), 1, + anon_sym_DOT, + ACTIONS(3564), 1, + anon_sym_QMARK, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4712), 1, + anon_sym_LPAREN, + STATE(1637), 1, + sym_parameter_type_list, + STATE(2215), 1, + sym_type_parameters, + STATE(2250), 1, + sym_nullable_type, + STATE(2161), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2440), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [113770] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4717), 1, + anon_sym_AMP_AMP, + STATE(440), 1, + sym_logical_and_operator, + STATE(2168), 1, + aux_sym__logical_and_pattern_repeat1, + STATE(2162), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4715), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_PIPE_PIPE, + [113809] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1987), 1, + sym_cascade_section, + STATE(2173), 1, + aux_sym__expression_repeat1, + ACTIONS(2344), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2163), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2595), 3, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + ACTIONS(2593), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + [113850] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4721), 1, + anon_sym_async, + STATE(1987), 1, + sym_cascade_section, + STATE(2172), 1, + aux_sym__expression_repeat1, + ACTIONS(2184), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2164), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4719), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [113891] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2261), 1, + sym_nullable_type, + STATE(2165), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2574), 9, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_catch, + anon_sym_with, + anon_sym_implements, + [113928] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1787), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2223), 1, + sym_type_parameters, + STATE(2586), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3083), 1, + sym_interfaces, + STATE(2166), 2, + sym_comment, + sym_documentation_comment, + [113981] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4725), 1, + anon_sym_AMP_AMP, + STATE(440), 1, + sym_logical_and_operator, + STATE(2167), 3, + sym_comment, + sym_documentation_comment, + aux_sym__logical_and_pattern_repeat1, + ACTIONS(4723), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_PIPE_PIPE, + [114018] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4717), 1, + anon_sym_AMP_AMP, + STATE(440), 1, + sym_logical_and_operator, + STATE(2167), 1, + aux_sym__logical_and_pattern_repeat1, + STATE(2168), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4728), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_PIPE_PIPE, + [114057] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2411), 1, + anon_sym_DOT, + ACTIONS(3564), 1, + anon_sym_QMARK, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4730), 1, + anon_sym_LPAREN, + STATE(1637), 1, + sym_parameter_type_list, + STATE(2215), 1, + sym_type_parameters, + STATE(2217), 1, + sym_nullable_type, + STATE(2169), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2426), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [114104] = 17, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1801), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2259), 1, + sym_type_parameters, + STATE(2564), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3078), 1, + sym_interfaces, + STATE(2170), 2, + sym_comment, + sym_documentation_comment, + [114157] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4736), 1, + anon_sym_async, + STATE(1987), 1, + sym_cascade_section, + STATE(2172), 1, + aux_sym__expression_repeat1, + ACTIONS(2184), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2171), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4734), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [114198] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2569), 1, + anon_sym_async, + STATE(1987), 1, + sym_cascade_section, + ACTIONS(4738), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + STATE(2172), 3, + sym_comment, + sym_documentation_comment, + aux_sym__expression_repeat1, + ACTIONS(2567), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [114237] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(1987), 1, + sym_cascade_section, + ACTIONS(4741), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(2569), 3, + anon_sym_QMARK, + anon_sym_DOT, + anon_sym_QMARK_DOT, + STATE(2173), 3, + sym_comment, + sym_documentation_comment, + aux_sym__expression_repeat1, + ACTIONS(2567), 4, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + [114276] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4746), 1, + anon_sym_PIPE_PIPE, + STATE(436), 1, + sym_logical_or_operator, + STATE(2178), 1, + aux_sym__logical_or_pattern_repeat1, + STATE(2174), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4744), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [114314] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(969), 1, + anon_sym_default, + ACTIONS(971), 1, + anon_sym_case, + ACTIONS(4748), 1, + sym_identifier, + ACTIONS(4750), 1, + anon_sym_RBRACE, + STATE(429), 1, + sym_case_builtin, + STATE(2244), 1, + aux_sym_switch_block_repeat1, + STATE(2556), 1, + aux_sym_switch_statement_case_repeat1, + STATE(2654), 1, + sym_switch_statement_case, + STATE(2997), 1, + sym_label, + STATE(3433), 1, + sym_switch_statement_default, + STATE(2175), 2, + sym_comment, + sym_documentation_comment, + [114364] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + ACTIONS(4752), 1, + anon_sym_DOT, + STATE(1730), 1, + sym_nullable_type, + STATE(2385), 1, + sym_type_arguments, + ACTIONS(2485), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(2493), 2, + anon_sym_Function, + sym_identifier, + STATE(2176), 2, + sym_comment, + sym_documentation_comment, + [114410] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4758), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + STATE(2183), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2177), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114454] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4766), 1, + anon_sym_PIPE_PIPE, + STATE(436), 1, + sym_logical_or_operator, + STATE(2178), 3, + sym_comment, + sym_documentation_comment, + aux_sym__logical_or_pattern_repeat1, + ACTIONS(4764), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [114490] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4773), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + STATE(2184), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2179), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114534] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4781), 1, + anon_sym_LPAREN, + STATE(2180), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4779), 9, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + sym_const_builtin, + anon_sym_late, + sym_identifier, + [114568] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4783), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2182), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2181), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114612] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4785), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2185), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2182), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114656] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4787), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2185), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2183), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114700] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4789), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2202), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2184), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114744] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4791), 1, + anon_sym_DQUOTE, + ACTIONS(4797), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(4799), 1, + anon_sym_DOLLAR, + ACTIONS(4802), 1, + sym__unused_escape_sequence, + ACTIONS(4794), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2185), 3, + sym_comment, + sym_documentation_comment, + aux_sym__string_literal_double_quotes_multiple_repeat1, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114786] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1702), 1, + sym__function_type_tail, + STATE(2161), 1, + sym__function_builtin_identifier, + STATE(2188), 1, + aux_sym__function_type_tails, + STATE(2186), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2460), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_DOT, + ACTIONS(2462), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [114828] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1702), 1, + sym__function_type_tail, + STATE(2161), 1, + sym__function_builtin_identifier, + STATE(2188), 1, + aux_sym__function_type_tails, + STATE(2187), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2405), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_DOT, + ACTIONS(2407), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [114870] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3676), 1, + anon_sym_Function, + STATE(1702), 1, + sym__function_type_tail, + STATE(2161), 1, + sym__function_builtin_identifier, + ACTIONS(2464), 3, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_DOT, + ACTIONS(2466), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + STATE(2188), 3, + aux_sym__function_type_tails, + sym_comment, + sym_documentation_comment, + [114910] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4805), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2210), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2189), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [114954] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4807), 1, + anon_sym_EQ, + STATE(2190), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4694), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_BANG, + anon_sym_as, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [114988] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2191), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3080), 4, + anon_sym_QMARK, + sym_void_type, + anon_sym_Function, + sym_identifier, + ACTIONS(3078), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [115022] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4809), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2202), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2192), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115066] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4811), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2195), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2193), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115110] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4815), 1, + anon_sym_LPAREN, + STATE(2194), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4813), 9, + sym_void_type, + anon_sym_factory, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + anon_sym_static, + sym_const_builtin, + sym_identifier, + [115144] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4817), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2185), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2195), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115188] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4374), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2196), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1320), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + ACTIONS(2044), 4, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_SEMI, + [115226] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4819), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2202), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2197), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115270] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4821), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2197), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2198), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115314] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4823), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2192), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2199), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115358] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4825), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2208), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2200), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115402] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4827), 1, + anon_sym_EQ, + STATE(1808), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2587), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3301), 1, + sym_interfaces, + STATE(2201), 2, + sym_comment, + sym_documentation_comment, + [115452] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4832), 1, + anon_sym_SQUOTE, + ACTIONS(4835), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4837), 1, + anon_sym_DOLLAR, + ACTIONS(4840), 1, + sym__unused_escape_sequence, + ACTIONS(4829), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2202), 3, + sym_comment, + sym_documentation_comment, + aux_sym__string_literal_single_quotes_multiple_repeat1, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115494] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4746), 1, + anon_sym_PIPE_PIPE, + STATE(436), 1, + sym_logical_or_operator, + STATE(2174), 1, + aux_sym__logical_or_pattern_repeat1, + STATE(2203), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4843), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [115532] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4848), 1, + anon_sym_QMARK, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2694), 1, + sym_nullable_type, + STATE(3296), 1, + sym_type_bound, + ACTIONS(2044), 2, + anon_sym_LT, + anon_sym_Function, + ACTIONS(4845), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2204), 2, + sym_comment, + sym_documentation_comment, + [115578] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4853), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2211), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2205), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115622] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4855), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2185), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2206), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115666] = 16, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4827), 1, + anon_sym_EQ, + STATE(1764), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2608), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3281), 1, + sym_interfaces, + STATE(2207), 2, + sym_comment, + sym_documentation_comment, + [115716] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4857), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2202), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2208), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115760] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4859), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2206), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2209), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115804] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4771), 1, + anon_sym_SQUOTE, + ACTIONS(4775), 1, + anon_sym_DOLLAR, + ACTIONS(4777), 1, + sym__unused_escape_sequence, + ACTIONS(4861), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2202), 1, + aux_sym__string_literal_single_quotes_multiple_repeat1, + ACTIONS(4769), 2, + sym__template_chars_single, + anon_sym_DQUOTE, + STATE(2210), 2, + sym_comment, + sym_documentation_comment, + STATE(2514), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115848] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4754), 1, + anon_sym_DQUOTE, + ACTIONS(4760), 1, + anon_sym_DOLLAR, + ACTIONS(4762), 1, + sym__unused_escape_sequence, + ACTIONS(4863), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2185), 1, + aux_sym__string_literal_double_quotes_multiple_repeat1, + ACTIONS(4756), 2, + sym__template_chars_double, + anon_sym_SQUOTE, + STATE(2211), 2, + sym_comment, + sym_documentation_comment, + STATE(2554), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115892] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4865), 1, + anon_sym_DQUOTE, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + STATE(2240), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2212), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [115933] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2213), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4873), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [115964] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2214), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4875), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [115995] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2495), 1, + anon_sym_DOT, + ACTIONS(3642), 1, + anon_sym_QMARK, + ACTIONS(4877), 1, + anon_sym_LPAREN, + STATE(1649), 1, + sym_parameter_type_list, + STATE(2271), 1, + sym_nullable_type, + STATE(2215), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [116036] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(1743), 2, + sym_function_body, + sym__semicolon, + STATE(2216), 2, + sym_comment, + sym_documentation_comment, + [116079] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2529), 1, + anon_sym_DOT, + ACTIONS(3642), 1, + anon_sym_QMARK, + ACTIONS(4888), 1, + anon_sym_LPAREN, + STATE(1649), 1, + sym_parameter_type_list, + STATE(1689), 1, + sym_nullable_type, + STATE(2217), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2540), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [116120] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(4892), 1, + anon_sym_DQUOTE, + STATE(2283), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2218), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116161] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4896), 1, + anon_sym_SQUOTE, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + STATE(2235), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2219), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116202] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4904), 1, + anon_sym_EQ, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2336), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(4902), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(2220), 2, + sym_comment, + sym_documentation_comment, + [116247] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4904), 1, + anon_sym_EQ, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_QMARK, + anon_sym_LT, + ACTIONS(4902), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(2221), 2, + sym_comment, + sym_documentation_comment, + [116288] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(1744), 2, + sym_function_body, + sym__semicolon, + STATE(2222), 2, + sym_comment, + sym_documentation_comment, + [116331] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1764), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2608), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3281), 1, + sym_interfaces, + STATE(2223), 2, + sym_comment, + sym_documentation_comment, + [116378] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1773), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(2408), 1, + sym_type_parameters, + STATE(2619), 1, + sym_mixins, + STATE(3049), 1, + sym_interfaces, + STATE(2224), 2, + sym_comment, + sym_documentation_comment, + [116425] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4908), 1, + anon_sym_DQUOTE, + ACTIONS(4913), 1, + anon_sym_DOLLAR, + ACTIONS(4916), 1, + sym__unused_escape_sequence, + ACTIONS(4910), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2225), 3, + sym_comment, + sym_documentation_comment, + aux_sym__string_literal_double_quotes_repeat1, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116464] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4922), 1, + anon_sym_SQUOTE, + ACTIONS(4924), 1, + anon_sym_DOLLAR, + ACTIONS(4927), 1, + sym__unused_escape_sequence, + ACTIONS(4919), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2226), 3, + sym_comment, + sym_documentation_comment, + aux_sym__string_literal_single_quotes_repeat1, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116503] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2227), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4723), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [116534] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2228), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4930), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [116565] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4932), 1, + anon_sym_DQUOTE, + ACTIONS(4938), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(4940), 1, + anon_sym_DOLLAR, + STATE(2389), 1, + sym__sub_string_test, + STATE(2229), 3, + sym_comment, + sym_documentation_comment, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + ACTIONS(4935), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [116604] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4945), 1, + anon_sym_if, + ACTIONS(4947), 1, + anon_sym_deferred, + STATE(2446), 1, + aux_sym_configurable_uri_repeat1, + STATE(2610), 1, + sym_configuration_uri, + STATE(3164), 1, + sym__deferred, + STATE(2230), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4943), 4, + anon_sym_as, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [116645] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4952), 1, + anon_sym_SQUOTE, + ACTIONS(4955), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4957), 1, + anon_sym_DOLLAR, + STATE(2411), 1, + sym__sub_string_test, + STATE(2231), 3, + sym_comment, + sym_documentation_comment, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + ACTIONS(4949), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [116684] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(4962), 1, + anon_sym_DOT, + STATE(906), 1, + sym_arguments, + STATE(2849), 1, + sym_argument_part, + STATE(2852), 1, + sym_type_arguments, + STATE(2232), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4960), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [116727] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(149), 1, + sym_assert_builtin, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(4964), 1, + sym_identifier, + STATE(2409), 1, + sym_initializer_list_entry, + STATE(2830), 1, + sym_super, + STATE(3541), 1, + sym_this, + STATE(2233), 2, + sym_comment, + sym_documentation_comment, + STATE(2467), 2, + sym_assertion, + sym_field_initializer, + [116772] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(4966), 1, + anon_sym_COMMA, + ACTIONS(4968), 1, + anon_sym_SEMI, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2827), 1, + aux_sym__identifier_list_repeat1, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(2234), 2, + sym_comment, + sym_documentation_comment, + [116815] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(4970), 1, + anon_sym_SQUOTE, + STATE(2226), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2235), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116856] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(4972), 1, + anon_sym_SQUOTE, + STATE(2241), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2236), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [116897] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4978), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + STATE(2242), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2237), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [116938] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4986), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + STATE(2243), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2238), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [116979] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2239), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4992), 4, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + ACTIONS(4990), 5, + sym_void_type, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [117012] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(4994), 1, + anon_sym_DQUOTE, + STATE(2225), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2240), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117053] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(4996), 1, + anon_sym_SQUOTE, + STATE(2226), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2241), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117094] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(4998), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2229), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2242), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [117135] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5000), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2231), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2243), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [117176] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5002), 1, + sym_identifier, + ACTIONS(5005), 1, + anon_sym_RBRACE, + ACTIONS(5007), 1, + anon_sym_default, + ACTIONS(5009), 1, + anon_sym_case, + STATE(429), 1, + sym_case_builtin, + STATE(2569), 1, + aux_sym_switch_statement_case_repeat1, + STATE(2654), 1, + sym_switch_statement_case, + STATE(2997), 1, + sym_label, + STATE(2244), 3, + sym_comment, + sym_documentation_comment, + aux_sym_switch_block_repeat1, + [117221] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5014), 1, + anon_sym_COLON, + ACTIONS(5016), 1, + anon_sym_SEMI, + ACTIONS(5018), 1, + anon_sym_async, + STATE(2545), 1, + sym_initializers, + STATE(3559), 1, + sym_redirection, + STATE(2245), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5012), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [117262] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5020), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2247), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2246), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [117303] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5022), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2229), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2247), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [117344] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(149), 1, + sym_assert_builtin, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(5024), 1, + sym_identifier, + STATE(2409), 1, + sym_initializer_list_entry, + STATE(2804), 1, + sym_super, + STATE(3516), 1, + sym_this, + STATE(2248), 2, + sym_comment, + sym_documentation_comment, + STATE(2467), 2, + sym_assertion, + sym_field_initializer, + [117389] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2249), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5028), 4, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + ACTIONS(5026), 5, + sym_void_type, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [117422] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2495), 1, + anon_sym_DOT, + ACTIONS(3642), 1, + anon_sym_QMARK, + ACTIONS(4877), 1, + anon_sym_LPAREN, + STATE(1649), 1, + sym_parameter_type_list, + STATE(1689), 1, + sym_nullable_type, + STATE(2250), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2503), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [117463] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5030), 1, + anon_sym_DQUOTE, + STATE(2255), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2251), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117504] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4584), 1, + anon_sym_DOT, + STATE(1607), 1, + sym__type_dot_identifier, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(3607), 1, + sym_formal_parameter_list, + STATE(2252), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2044), 4, + anon_sym_QMARK, + anon_sym_LT, + anon_sym_Function, + anon_sym_operator, + [117545] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5032), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2257), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2253), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [117586] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5034), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2258), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2254), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [117627] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5036), 1, + anon_sym_DQUOTE, + STATE(2225), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2255), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117668] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5038), 1, + anon_sym_SQUOTE, + STATE(2226), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2256), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117709] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5040), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2229), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2257), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [117750] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5042), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2231), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2258), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [117791] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4666), 1, + anon_sym_extends, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1808), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2587), 1, + sym_superclass, + STATE(3074), 1, + sym_mixins, + STATE(3301), 1, + sym_interfaces, + STATE(2259), 2, + sym_comment, + sym_documentation_comment, + [117838] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(5046), 1, + anon_sym_DOT, + STATE(906), 1, + sym_arguments, + STATE(2759), 1, + sym_argument_part, + STATE(2760), 1, + sym_type_arguments, + STATE(2260), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5044), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [117881] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2261), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2718), 9, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_GT, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_catch, + anon_sym_with, + anon_sym_implements, + [117912] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5048), 1, + anon_sym_DQUOTE, + STATE(2267), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2262), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117953] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5050), 1, + anon_sym_SQUOTE, + STATE(2268), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2263), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [117994] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5052), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2282), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2264), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118035] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5054), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2269), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2265), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [118076] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5056), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2270), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2266), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118117] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5058), 1, + anon_sym_DQUOTE, + STATE(2225), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2267), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118158] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5060), 1, + anon_sym_SQUOTE, + STATE(2226), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2268), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118199] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5062), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2229), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2269), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [118240] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5064), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2231), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2270), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118281] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2505), 1, + anon_sym_DOT, + ACTIONS(3707), 1, + anon_sym_QMARK, + ACTIONS(5066), 1, + anon_sym_LPAREN, + STATE(1644), 1, + sym_parameter_type_list, + STATE(1700), 1, + sym_nullable_type, + STATE(2271), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2513), 4, + anon_sym_Function, + anon_sym_this, + anon_sym_super, + sym_identifier, + [118322] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5069), 1, + anon_sym_DQUOTE, + STATE(2277), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2272), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118363] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5071), 1, + anon_sym_SQUOTE, + STATE(2278), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2273), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118404] = 15, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1771), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(2462), 1, + sym_type_parameters, + STATE(2570), 1, + sym_mixins, + STATE(3253), 1, + sym_interfaces, + STATE(2274), 2, + sym_comment, + sym_documentation_comment, + [118451] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5073), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2279), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2275), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [118492] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5075), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2280), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2276), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118533] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5077), 1, + anon_sym_DQUOTE, + STATE(2225), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2277), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118574] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5079), 1, + anon_sym_SQUOTE, + STATE(2226), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2278), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118615] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4974), 1, + anon_sym_DQUOTE, + ACTIONS(4980), 1, + anon_sym_DOLLAR, + ACTIONS(5081), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + STATE(2229), 1, + aux_sym__raw_string_literal_double_quotes_multiple_repeat1, + STATE(2389), 1, + sym__sub_string_test, + STATE(2279), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4976), 4, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [118656] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5083), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2231), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2280), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118697] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5087), 1, + anon_sym_class, + ACTIONS(5089), 1, + anon_sym_interface, + ACTIONS(5091), 1, + anon_sym_base, + ACTIONS(5093), 1, + anon_sym_mixin, + STATE(3045), 1, + sym_base, + STATE(3453), 1, + sym_mixin, + STATE(3619), 1, + sym_interface, + ACTIONS(5085), 2, + anon_sym_final, + anon_sym_inline, + STATE(2281), 2, + sym_comment, + sym_documentation_comment, + [118742] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4984), 1, + anon_sym_SQUOTE, + ACTIONS(4988), 1, + anon_sym_DOLLAR, + ACTIONS(5095), 1, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + STATE(2231), 1, + aux_sym__raw_string_literal_single_quotes_multiple_repeat1, + STATE(2411), 1, + sym__sub_string_test, + STATE(2282), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4982), 4, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [118783] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4869), 1, + anon_sym_DOLLAR, + ACTIONS(4871), 1, + sym__unused_escape_sequence, + ACTIONS(5097), 1, + anon_sym_DQUOTE, + STATE(2225), 1, + aux_sym__string_literal_double_quotes_repeat1, + ACTIONS(4867), 2, + sym__template_chars_double_single, + anon_sym_SQUOTE, + STATE(2283), 2, + sym_comment, + sym_documentation_comment, + STATE(2596), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [118824] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(149), 1, + sym_assert_builtin, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(5024), 1, + sym_identifier, + STATE(2804), 1, + sym_super, + STATE(2990), 1, + sym_initializer_list_entry, + STATE(3043), 1, + sym_this, + STATE(2284), 2, + sym_comment, + sym_documentation_comment, + STATE(2467), 2, + sym_assertion, + sym_field_initializer, + [118869] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2285), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5099), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [118900] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2286), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4684), 9, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + [118931] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(149), 1, + sym_assert_builtin, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(4964), 1, + sym_identifier, + STATE(2327), 1, + sym_initializer_list_entry, + STATE(2829), 1, + sym_this, + STATE(2830), 1, + sym_super, + STATE(2287), 2, + sym_comment, + sym_documentation_comment, + STATE(2467), 2, + sym_assertion, + sym_field_initializer, + [118976] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4898), 1, + anon_sym_DOLLAR, + ACTIONS(4900), 1, + sym__unused_escape_sequence, + ACTIONS(5101), 1, + anon_sym_SQUOTE, + STATE(2256), 1, + aux_sym__string_literal_single_quotes_repeat1, + ACTIONS(4894), 2, + sym__template_chars_single_single, + anon_sym_DQUOTE, + STATE(2288), 2, + sym_comment, + sym_documentation_comment, + STATE(2626), 3, + sym_template_substitution, + sym__sub_string_test, + sym_escape_sequence, + [119017] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5106), 1, + anon_sym_in, + STATE(2289), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5103), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_SEMI, + [119049] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2636), 1, + anon_sym_QMARK, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2375), 1, + sym_arguments, + STATE(2290), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2634), 5, + anon_sym_LBRACK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [119085] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2348), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(5108), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(2291), 2, + sym_comment, + sym_documentation_comment, + [119127] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5110), 1, + anon_sym_on, + STATE(1754), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2476), 1, + sym_type_parameters, + STATE(3115), 1, + sym_interfaces, + STATE(2292), 2, + sym_comment, + sym_documentation_comment, + [119171] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5114), 1, + anon_sym_COMMA, + ACTIONS(5117), 1, + anon_sym_async, + STATE(2293), 3, + sym_comment, + sym_documentation_comment, + aux_sym_initializers_repeat1, + ACTIONS(5112), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [119205] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5119), 1, + anon_sym_DQUOTE, + ACTIONS(5124), 1, + anon_sym_DOLLAR, + STATE(2531), 1, + sym__sub_string_test, + STATE(2294), 3, + sym_comment, + sym_documentation_comment, + aux_sym__raw_string_literal_double_quotes_repeat1, + ACTIONS(5121), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [119241] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5129), 1, + anon_sym_async, + ACTIONS(5131), 1, + anon_sym_native, + STATE(2539), 1, + sym__native, + STATE(2295), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5127), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [119277] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5136), 1, + anon_sym_SQUOTE, + ACTIONS(5138), 1, + anon_sym_DOLLAR, + STATE(2500), 1, + sym__sub_string_test, + STATE(2296), 3, + sym_comment, + sym_documentation_comment, + aux_sym__raw_string_literal_single_quotes_repeat1, + ACTIONS(5133), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [119313] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5141), 1, + anon_sym_DQUOTE, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + STATE(2303), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2297), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [119351] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5149), 1, + anon_sym_SQUOTE, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + STATE(2304), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2298), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [119389] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5155), 1, + anon_sym_async, + STATE(2499), 1, + sym__native, + STATE(2299), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5153), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [119425] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5159), 1, + anon_sym_async, + STATE(2525), 1, + sym__native, + STATE(2300), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5157), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [119461] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1729), 1, + anon_sym_RBRACE, + ACTIONS(5161), 1, + sym_identifier, + ACTIONS(5163), 1, + anon_sym_SEMI, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2756), 1, + sym_enum_constant, + STATE(3500), 1, + sym__metadata, + STATE(2301), 2, + sym_comment, + sym_documentation_comment, + [119505] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2348), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(5165), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2302), 2, + sym_comment, + sym_documentation_comment, + [119547] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5167), 1, + anon_sym_DQUOTE, + STATE(2294), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2303), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [119585] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5169), 1, + anon_sym_SQUOTE, + STATE(2296), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2304), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [119623] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5171), 1, + anon_sym_DQUOTE, + STATE(2294), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2305), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [119661] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5176), 1, + anon_sym_in, + STATE(2306), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5173), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_SEMI, + [119693] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3068), 1, + anon_sym_QMARK, + STATE(2307), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3066), 7, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + sym_identifier, + [119725] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1887), 1, + anon_sym_RBRACE, + ACTIONS(5161), 1, + sym_identifier, + ACTIONS(5178), 1, + anon_sym_SEMI, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2756), 1, + sym_enum_constant, + STATE(3500), 1, + sym__metadata, + STATE(2308), 2, + sym_comment, + sym_documentation_comment, + [119769] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5180), 1, + anon_sym_as, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1616), 1, + sym__semicolon, + STATE(2490), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + STATE(3499), 1, + sym__as, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2309), 2, + sym_comment, + sym_documentation_comment, + [119811] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5186), 1, + anon_sym_on, + STATE(1814), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2503), 1, + sym_type_parameters, + STATE(3208), 1, + sym_interfaces, + STATE(2310), 2, + sym_comment, + sym_documentation_comment, + [119855] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(3141), 1, + sym_type_parameter, + STATE(2311), 2, + sym_comment, + sym_documentation_comment, + [119899] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2312), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5190), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(5192), 4, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + [119931] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5196), 1, + aux_sym__sub_string_test_token1, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + STATE(2313), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5198), 3, + sym__template_chars_single, + sym__template_chars_raw_slash, + sym__unused_escape_sequence, + ACTIONS(5194), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + [119965] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5206), 1, + anon_sym_async, + STATE(2491), 1, + sym__native, + STATE(2314), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5204), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120001] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5208), 1, + anon_sym_on, + STATE(1763), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(2492), 1, + sym_type_parameters, + STATE(3157), 1, + sym_interfaces, + STATE(2315), 2, + sym_comment, + sym_documentation_comment, + [120045] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2521), 1, + sym_nullable_type, + STATE(2316), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5210), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [120079] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5212), 1, + anon_sym_DQUOTE, + STATE(2323), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2317), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120117] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5214), 1, + anon_sym_SQUOTE, + STATE(2324), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2318), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120155] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2551), 1, + sym_nullable_type, + STATE(2319), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5216), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [120189] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5220), 1, + anon_sym_COMMA, + ACTIONS(5222), 1, + anon_sym_async, + STATE(2293), 1, + aux_sym_initializers_repeat1, + STATE(2320), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5218), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120225] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5226), 1, + anon_sym_async, + STATE(2520), 1, + sym__native, + STATE(2321), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5224), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120261] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4518), 1, + anon_sym_LPAREN, + ACTIONS(2690), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(2322), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2692), 5, + anon_sym_Function, + anon_sym_get, + anon_sym_operator, + anon_sym_set, + sym_identifier, + [120295] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5228), 1, + anon_sym_DQUOTE, + STATE(2294), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2323), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120333] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5230), 1, + anon_sym_SQUOTE, + STATE(2296), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2324), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120371] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3072), 1, + anon_sym_QMARK, + STATE(2325), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3070), 7, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + sym_identifier, + [120403] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5232), 1, + anon_sym_DQUOTE, + STATE(2305), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2326), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120441] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5220), 1, + anon_sym_COMMA, + ACTIONS(5236), 1, + anon_sym_async, + STATE(2320), 1, + aux_sym_initializers_repeat1, + STATE(2327), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5234), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120477] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5238), 1, + anon_sym_SQUOTE, + STATE(2296), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2328), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120515] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5240), 1, + anon_sym_DQUOTE, + STATE(2341), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2329), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120553] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5242), 1, + anon_sym_SQUOTE, + STATE(2342), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2330), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120591] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5244), 1, + anon_sym_DQUOTE, + STATE(2338), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2331), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120629] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5246), 1, + anon_sym_SQUOTE, + STATE(2339), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2332), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120667] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5250), 1, + anon_sym_async, + STATE(2480), 1, + sym__native, + STATE(2333), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5248), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120703] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5252), 1, + anon_sym_SQUOTE, + STATE(2328), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2334), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120741] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2348), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + ACTIONS(5254), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2335), 2, + sym_comment, + sym_documentation_comment, + [120783] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5258), 1, + anon_sym_async, + STATE(2515), 1, + sym__native, + STATE(2336), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5256), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120819] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2741), 1, + sym_type_parameter, + STATE(2337), 2, + sym_comment, + sym_documentation_comment, + [120863] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5260), 1, + anon_sym_DQUOTE, + STATE(2294), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2338), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [120901] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5262), 1, + anon_sym_SQUOTE, + STATE(2296), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2339), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [120939] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5266), 1, + anon_sym_async, + STATE(2542), 1, + sym__native, + STATE(2340), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5264), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [120975] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5145), 1, + anon_sym_DOLLAR, + ACTIONS(5268), 1, + anon_sym_DQUOTE, + STATE(2294), 1, + aux_sym__raw_string_literal_double_quotes_repeat1, + STATE(2531), 1, + sym__sub_string_test, + STATE(2341), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5143), 4, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + sym__unused_escape_sequence, + [121013] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5151), 1, + anon_sym_DOLLAR, + ACTIONS(5270), 1, + anon_sym_SQUOTE, + STATE(2296), 1, + aux_sym__raw_string_literal_single_quotes_repeat1, + STATE(2500), 1, + sym__sub_string_test, + STATE(2342), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5147), 4, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + sym__unused_escape_sequence, + [121051] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5274), 1, + anon_sym_async, + STATE(2547), 1, + sym__native, + STATE(2343), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5272), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [121087] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2344), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5276), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(5278), 4, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + [121119] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2769), 1, + sym_type_parameter, + STATE(2345), 2, + sym_comment, + sym_documentation_comment, + [121163] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5282), 1, + anon_sym_LPAREN, + STATE(2346), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5280), 7, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + sym_const_builtin, + anon_sym_late, + sym_identifier, + [121195] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2347), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4764), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + anon_sym_PIPE_PIPE, + [121225] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2527), 1, + sym_nullable_type, + STATE(2348), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5284), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [121259] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2846), 1, + sym_type_parameter, + STATE(2349), 2, + sym_comment, + sym_documentation_comment, + [121303] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2350), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5106), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_SEMI, + anon_sym_in, + [121333] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1687), 1, + anon_sym_QMARK, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2429), 1, + sym_arguments, + STATE(2351), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1681), 5, + anon_sym_LBRACK, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [121369] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(5288), 1, + aux_sym__sub_string_test_token1, + STATE(2352), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5290), 3, + sym__template_chars_double, + sym__template_chars_raw_slash, + sym__unused_escape_sequence, + ACTIONS(5286), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + [121403] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2897), 1, + sym_type_parameter, + STATE(2353), 2, + sym_comment, + sym_documentation_comment, + [121447] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4594), 1, + anon_sym_native, + ACTIONS(5295), 1, + anon_sym_COLON, + ACTIONS(5297), 1, + anon_sym_async, + STATE(2354), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5292), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [121483] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2355), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5300), 4, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_r_DQUOTE, + anon_sym_r_SQUOTE, + ACTIONS(5302), 4, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_r_DQUOTE_DQUOTE_DQUOTE, + anon_sym_r_SQUOTE_SQUOTE_SQUOTE, + [121515] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2941), 1, + sym_type_parameter, + STATE(2356), 2, + sym_comment, + sym_documentation_comment, + [121559] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5131), 1, + anon_sym_native, + ACTIONS(5306), 1, + anon_sym_async, + STATE(2508), 1, + sym__native, + STATE(2357), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5304), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [121595] = 14, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5188), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2477), 1, + sym_nullable_type, + STATE(2725), 1, + sym__metadata, + STATE(2958), 1, + sym_type_parameter, + STATE(2358), 2, + sym_comment, + sym_documentation_comment, + [121639] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2359), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5308), 8, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_SEMI, + anon_sym_in, + [121669] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + STATE(1966), 1, + sym_function_body, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2360), 2, + sym_comment, + sym_documentation_comment, + [121708] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2361), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5176), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + anon_sym_SEMI, + [121737] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5310), 1, + anon_sym_DQUOTE, + STATE(2362), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 6, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [121768] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5316), 1, + anon_sym_async, + STATE(2363), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5314), 6, + anon_sym_LBRACE, + anon_sym_COLON, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [121799] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3088), 1, + anon_sym_QMARK, + STATE(2364), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3086), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [121830] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5320), 1, + anon_sym_async, + STATE(2365), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5318), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [121861] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3092), 1, + anon_sym_QMARK, + STATE(2366), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3090), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [121892] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5310), 1, + anon_sym_SQUOTE, + STATE(2367), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 6, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [121923] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1679), 1, + anon_sym_QMARK, + STATE(2368), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1677), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [121954] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1657), 1, + anon_sym_QMARK, + STATE(2369), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1655), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [121985] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1665), 1, + anon_sym_QMARK, + STATE(2370), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1663), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122016] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1669), 1, + anon_sym_QMARK, + STATE(2371), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1667), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122047] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5324), 1, + anon_sym_EQ, + ACTIONS(5326), 1, + anon_sym_async, + STATE(2372), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5322), 5, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [122080] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1709), 1, + anon_sym_QMARK, + STATE(2373), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1707), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122111] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(5330), 1, + aux_sym__sub_string_test_token1, + STATE(2374), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5328), 3, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + ACTIONS(5332), 3, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + sym__unused_escape_sequence, + [122144] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2880), 1, + anon_sym_QMARK, + STATE(2375), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2878), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122175] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2888), 1, + anon_sym_QMARK, + STATE(2376), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2886), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122206] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2892), 1, + anon_sym_QMARK, + STATE(2377), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2890), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122237] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2896), 1, + anon_sym_QMARK, + STATE(2378), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2894), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122268] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5336), 1, + anon_sym_if, + STATE(2610), 1, + sym_configuration_uri, + STATE(2379), 3, + sym_comment, + sym_documentation_comment, + aux_sym_configurable_uri_repeat1, + ACTIONS(5334), 4, + anon_sym_as, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [122301] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2916), 1, + anon_sym_QMARK, + STATE(2380), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2914), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122332] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2936), 1, + anon_sym_QMARK, + STATE(2381), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2934), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122363] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2944), 1, + anon_sym_QMARK, + STATE(2382), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2942), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122394] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2952), 1, + anon_sym_QMARK, + STATE(2383), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2950), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122425] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(45), 1, + anon_sym_Function, + STATE(1702), 1, + sym__function_type_tail, + STATE(2161), 1, + sym__function_builtin_identifier, + STATE(2186), 1, + aux_sym__function_type_tails, + STATE(2384), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4165), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [122462] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4654), 1, + anon_sym_LPAREN, + STATE(1736), 1, + sym_nullable_type, + ACTIONS(2586), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(2591), 2, + anon_sym_Function, + sym_identifier, + STATE(2385), 2, + sym_comment, + sym_documentation_comment, + [122499] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2626), 1, + anon_sym_QMARK, + STATE(2386), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2622), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122530] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2632), 1, + anon_sym_QMARK, + STATE(2387), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2628), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122561] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3096), 1, + anon_sym_QMARK, + STATE(2388), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3094), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122592] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5286), 1, + anon_sym_DQUOTE, + STATE(2389), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5290), 6, + sym__template_chars_double, + sym__template_chars_raw_slash, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [122623] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2972), 1, + anon_sym_QMARK, + STATE(2390), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2970), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122654] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3100), 1, + anon_sym_QMARK, + STATE(2391), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3098), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122685] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3750), 1, + anon_sym_DOT, + ACTIONS(5339), 1, + anon_sym_EQ, + STATE(1607), 1, + sym__type_dot_identifier, + ACTIONS(1320), 2, + anon_sym_Function, + sym_identifier, + ACTIONS(2044), 2, + anon_sym_QMARK, + anon_sym_LT, + STATE(2392), 2, + sym_comment, + sym_documentation_comment, + [122722] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(5341), 1, + anon_sym_EQ_GT, + ACTIONS(5343), 1, + anon_sym_async, + STATE(2456), 1, + sym_block, + STATE(2461), 1, + sym_function_expression_body, + ACTIONS(5345), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2393), 2, + sym_comment, + sym_documentation_comment, + [122761] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1008), 1, + anon_sym_QMARK, + STATE(2394), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1006), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122792] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3032), 1, + anon_sym_QMARK, + STATE(2395), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3030), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122823] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3036), 1, + anon_sym_QMARK, + STATE(2396), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3034), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122854] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3040), 1, + anon_sym_QMARK, + STATE(2397), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3038), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122885] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5018), 1, + anon_sym_async, + ACTIONS(5347), 1, + anon_sym_native, + STATE(3559), 1, + sym__native, + STATE(2398), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5012), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [122920] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + STATE(1980), 1, + sym_function_body, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2399), 2, + sym_comment, + sym_documentation_comment, + [122959] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3048), 1, + anon_sym_QMARK, + STATE(2400), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3046), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [122990] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(1721), 1, + anon_sym_operator, + ACTIONS(5349), 1, + sym_identifier, + STATE(1523), 1, + sym__operator, + STATE(2444), 1, + sym__get, + STATE(2445), 1, + sym__set, + STATE(2401), 2, + sym_comment, + sym_documentation_comment, + [123031] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3060), 1, + anon_sym_QMARK, + STATE(2402), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3058), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123062] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3064), 1, + anon_sym_QMARK, + STATE(2403), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3062), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123093] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3104), 1, + anon_sym_QMARK, + STATE(2404), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3102), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123124] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5354), 1, + anon_sym_async, + STATE(2405), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5352), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [123155] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2816), 1, + anon_sym_QMARK, + STATE(2406), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2812), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123186] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5356), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2299), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2407), 2, + sym_comment, + sym_documentation_comment, + [123227] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1782), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(2607), 1, + sym_mixins, + STATE(3139), 1, + sym_interfaces, + STATE(2408), 2, + sym_comment, + sym_documentation_comment, + [123268] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5117), 1, + anon_sym_async, + STATE(2409), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5112), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [123299] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3084), 1, + anon_sym_QMARK, + STATE(2410), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3082), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123330] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5194), 1, + anon_sym_SQUOTE, + STATE(2411), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5198), 6, + sym__template_chars_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [123361] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2900), 1, + anon_sym_QMARK, + STATE(2412), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2898), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123392] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5358), 1, + sym_identifier, + STATE(2444), 1, + sym__get, + STATE(2445), 1, + sym__set, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3182), 1, + sym_initialized_identifier_list, + STATE(2413), 2, + sym_comment, + sym_documentation_comment, + [123433] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + STATE(530), 1, + sym_function_body, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2414), 2, + sym_comment, + sym_documentation_comment, + [123472] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2872), 1, + anon_sym_QMARK, + STATE(2415), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2870), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123503] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2820), 1, + anon_sym_QMARK, + STATE(2416), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2818), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123534] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5360), 1, + anon_sym_LBRACE, + ACTIONS(5362), 1, + anon_sym_EQ_GT, + ACTIONS(5364), 1, + anon_sym_async, + STATE(940), 1, + sym_block, + STATE(946), 1, + sym_function_expression_body, + ACTIONS(5366), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2417), 2, + sym_comment, + sym_documentation_comment, + [123573] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + STATE(1730), 1, + sym_nullable_type, + STATE(2385), 1, + sym_type_arguments, + ACTIONS(2493), 2, + anon_sym_Function, + sym_identifier, + STATE(2418), 2, + sym_comment, + sym_documentation_comment, + [123612] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2876), 1, + anon_sym_QMARK, + STATE(2419), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2874), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123643] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1332), 1, + anon_sym_QMARK, + STATE(2420), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1322), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123674] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5368), 1, + anon_sym_LBRACE, + ACTIONS(5370), 1, + anon_sym_EQ_GT, + ACTIONS(5372), 1, + anon_sym_async, + STATE(1262), 1, + sym_block, + STATE(1263), 1, + sym_function_expression_body, + ACTIONS(5374), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2421), 2, + sym_comment, + sym_documentation_comment, + [123713] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5378), 1, + anon_sym_EQ, + ACTIONS(5380), 1, + anon_sym_async, + STATE(2422), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5376), 5, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + anon_sym_native, + [123746] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(5384), 1, + aux_sym__sub_string_test_token1, + STATE(2423), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5382), 3, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + ACTIONS(5386), 3, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + sym__unused_escape_sequence, + [123779] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5358), 1, + sym_identifier, + STATE(2444), 1, + sym__get, + STATE(2445), 1, + sym__set, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3286), 1, + sym_initialized_identifier_list, + STATE(2424), 2, + sym_comment, + sym_documentation_comment, + [123820] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5390), 1, + anon_sym_async, + STATE(2425), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5388), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [123851] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3116), 1, + anon_sym_QMARK, + STATE(2426), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3114), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123882] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5394), 1, + anon_sym_async, + STATE(2427), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5392), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [123913] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2908), 1, + anon_sym_QMARK, + STATE(2428), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2906), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123944] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1855), 1, + anon_sym_QMARK, + STATE(2429), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1853), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [123975] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2828), 1, + anon_sym_QMARK, + STATE(2430), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2826), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124006] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3108), 1, + anon_sym_QMARK, + STATE(2431), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3106), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124037] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3056), 1, + anon_sym_QMARK, + STATE(2432), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3054), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124068] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2696), 1, + anon_sym_QMARK, + STATE(2433), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2694), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124099] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2860), 1, + anon_sym_QMARK, + STATE(2434), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2858), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124130] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3120), 1, + anon_sym_QMARK, + STATE(2435), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(3118), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124161] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5396), 1, + anon_sym_LBRACE, + ACTIONS(5398), 1, + anon_sym_EQ_GT, + ACTIONS(5400), 1, + anon_sym_async, + STATE(1157), 1, + sym_block, + STATE(1158), 1, + sym_function_expression_body, + ACTIONS(5402), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2436), 2, + sym_comment, + sym_documentation_comment, + [124200] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + STATE(1955), 1, + sym_function_body, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2437), 2, + sym_comment, + sym_documentation_comment, + [124239] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1687), 1, + anon_sym_QMARK, + STATE(2438), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1681), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124270] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5406), 1, + anon_sym_async, + STATE(2439), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5404), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [124301] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1733), 1, + anon_sym_QMARK, + STATE(2440), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1731), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124332] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2976), 1, + anon_sym_QMARK, + STATE(2441), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2974), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124363] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2986), 1, + anon_sym_QMARK, + STATE(2442), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2984), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124394] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2990), 1, + anon_sym_QMARK, + STATE(2443), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2988), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124425] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5408), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2343), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2444), 2, + sym_comment, + sym_documentation_comment, + [124466] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5410), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2343), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2445), 2, + sym_comment, + sym_documentation_comment, + [124507] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4945), 1, + anon_sym_if, + STATE(2379), 1, + aux_sym_configurable_uri_repeat1, + STATE(2610), 1, + sym_configuration_uri, + STATE(2446), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5412), 4, + anon_sym_as, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [124542] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2810), 1, + anon_sym_QMARK, + STATE(2447), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2808), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124573] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2884), 1, + anon_sym_QMARK, + STATE(2448), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2882), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124604] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5414), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2299), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2449), 2, + sym_comment, + sym_documentation_comment, + [124645] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5418), 1, + anon_sym_async, + STATE(2450), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5416), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [124676] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5420), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2775), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2451), 2, + sym_comment, + sym_documentation_comment, + [124717] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5422), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2775), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2452), 2, + sym_comment, + sym_documentation_comment, + [124758] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2912), 1, + anon_sym_QMARK, + STATE(2453), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2910), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124789] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5426), 1, + anon_sym_async, + STATE(2454), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5424), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [124820] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2455), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5428), 7, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + anon_sym_when, + [124849] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2924), 1, + anon_sym_QMARK, + STATE(2456), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2922), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124880] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2928), 1, + anon_sym_QMARK, + STATE(2457), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2926), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124911] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2832), 1, + anon_sym_QMARK, + STATE(2458), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2830), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [124942] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + STATE(2616), 1, + sym_nullable_type, + ACTIONS(2574), 2, + anon_sym_LPAREN, + anon_sym_DOT, + STATE(2459), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4165), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [124977] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(4882), 1, + anon_sym_EQ_GT, + ACTIONS(4884), 1, + anon_sym_async, + STATE(447), 1, + sym_block, + STATE(1971), 1, + sym_function_body, + ACTIONS(4886), 2, + anon_sym_async_STAR, + anon_sym_sync_STAR, + STATE(2460), 2, + sym_comment, + sym_documentation_comment, + [125016] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2940), 1, + anon_sym_QMARK, + STATE(2461), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(2938), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [125047] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4668), 1, + anon_sym_with, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1800), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(2581), 1, + sym_mixins, + STATE(3287), 1, + sym_interfaces, + STATE(2462), 2, + sym_comment, + sym_documentation_comment, + [125088] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1291), 1, + anon_sym_QMARK, + STATE(2463), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(1271), 6, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_BANG, + anon_sym_DOT, + anon_sym_QMARK_DOT, + [125119] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5430), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(2980), 1, + sym__formal_parameter_part, + STATE(2464), 2, + sym_comment, + sym_documentation_comment, + [125160] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5432), 1, + sym_identifier, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(2980), 1, + sym__formal_parameter_part, + STATE(2465), 2, + sym_comment, + sym_documentation_comment, + [125201] = 13, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5358), 1, + sym_identifier, + STATE(2444), 1, + sym__get, + STATE(2445), 1, + sym__set, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3570), 1, + sym_initialized_identifier_list, + STATE(2466), 2, + sym_comment, + sym_documentation_comment, + [125242] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5436), 1, + anon_sym_async, + STATE(2467), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5434), 6, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [125273] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5440), 1, + anon_sym_LPAREN, + STATE(2468), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5438), 5, + sym_void_type, + anon_sym_Function, + anon_sym_get, + anon_sym_set, + sym_identifier, + [125303] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2336), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2469), 2, + sym_comment, + sym_documentation_comment, + [125341] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(5442), 1, + sym_identifier, + ACTIONS(5444), 1, + anon_sym_QMARK, + STATE(768), 1, + sym_cascade_selector, + STATE(1196), 1, + sym_index_selector, + STATE(3047), 1, + sym_nullable_selector, + STATE(2470), 2, + sym_comment, + sym_documentation_comment, + [125379] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(5442), 1, + sym_identifier, + ACTIONS(5444), 1, + anon_sym_QMARK, + STATE(1196), 1, + sym_index_selector, + STATE(1213), 1, + sym_cascade_selector, + STATE(3047), 1, + sym_nullable_selector, + STATE(2471), 2, + sym_comment, + sym_documentation_comment, + [125417] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1575), 1, + sym__semicolon, + STATE(2576), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2472), 2, + sym_comment, + sym_documentation_comment, + [125453] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5448), 1, + anon_sym_SQUOTE, + STATE(2473), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5446), 5, + sym__template_chars_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [125483] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2474), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5450), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [125511] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2475), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 6, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [125539] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5186), 1, + anon_sym_on, + STATE(1814), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3208), 1, + sym_interfaces, + STATE(2476), 2, + sym_comment, + sym_documentation_comment, + [125577] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(2703), 1, + sym_nullable_type, + STATE(3307), 1, + sym_type_bound, + ACTIONS(5452), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2477), 2, + sym_comment, + sym_documentation_comment, + [125613] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2478), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5454), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [125641] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(3469), 1, + sym__formal_parameter_part, + STATE(2479), 2, + sym_comment, + sym_documentation_comment, + [125679] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5226), 1, + anon_sym_async, + STATE(2480), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5224), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [125709] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2481), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5456), 6, + anon_sym_final, + anon_sym_inline, + anon_sym_class, + anon_sym_interface, + anon_sym_base, + anon_sym_mixin, + [125737] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5444), 1, + anon_sym_QMARK, + ACTIONS(5458), 1, + sym_identifier, + ACTIONS(5460), 1, + anon_sym_LBRACK, + STATE(460), 1, + sym_cascade_selector, + STATE(584), 1, + sym_index_selector, + STATE(3222), 1, + sym_nullable_selector, + STATE(2482), 2, + sym_comment, + sym_documentation_comment, + [125775] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5464), 1, + anon_sym_SQUOTE, + STATE(2483), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5462), 5, + sym__template_chars_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [125805] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2357), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2484), 2, + sym_comment, + sym_documentation_comment, + [125843] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4945), 1, + anon_sym_if, + STATE(2446), 1, + aux_sym_configurable_uri_repeat1, + STATE(2610), 1, + sym_configuration_uri, + STATE(2485), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4943), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [125877] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5468), 1, + anon_sym_COLON, + STATE(543), 1, + sym__semicolon, + STATE(2486), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5466), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_else, + [125911] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2487), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5470), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [125939] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1590), 1, + sym__semicolon, + STATE(2548), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2488), 2, + sym_comment, + sym_documentation_comment, + [125975] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2775), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2489), 2, + sym_comment, + sym_documentation_comment, + [126013] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1612), 1, + sym__semicolon, + STATE(2576), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2490), 2, + sym_comment, + sym_documentation_comment, + [126049] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5474), 1, + anon_sym_async, + STATE(2491), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5472), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [126079] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5110), 1, + anon_sym_on, + STATE(1754), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3115), 1, + sym_interfaces, + STATE(2492), 2, + sym_comment, + sym_documentation_comment, + [126117] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2493), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5476), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [126145] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2299), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2494), 2, + sym_comment, + sym_documentation_comment, + [126183] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2495), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5478), 6, + anon_sym_as, + anon_sym_SEMI, + anon_sym_if, + anon_sym_show, + anon_sym_hide, + anon_sym_deferred, + [126211] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5444), 1, + anon_sym_QMARK, + ACTIONS(5480), 1, + sym_identifier, + ACTIONS(5482), 1, + anon_sym_LBRACK, + STATE(466), 1, + sym_cascade_selector, + STATE(659), 1, + sym_index_selector, + STATE(3111), 1, + sym_nullable_selector, + STATE(2496), 2, + sym_comment, + sym_documentation_comment, + [126249] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1581), 1, + sym__semicolon, + STATE(2538), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2497), 2, + sym_comment, + sym_documentation_comment, + [126285] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1572), 1, + sym__semicolon, + STATE(2472), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2498), 2, + sym_comment, + sym_documentation_comment, + [126321] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5486), 1, + anon_sym_async, + STATE(2499), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5484), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [126351] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2500), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5332), 6, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [126379] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2501), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5488), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [126407] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 1, + sym_cascade_section, + STATE(2110), 1, + aux_sym__expression_repeat1, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(4734), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(2502), 2, + sym_comment, + sym_documentation_comment, + [126441] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5490), 1, + anon_sym_on, + STATE(1740), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3131), 1, + sym_interfaces, + STATE(2503), 2, + sym_comment, + sym_documentation_comment, + [126479] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(939), 1, + sym_cascade_section, + STATE(2110), 1, + aux_sym__expression_repeat1, + ACTIONS(2156), 2, + anon_sym_DOT_DOT, + anon_sym_QMARK_DOT_DOT, + ACTIONS(4719), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(2504), 2, + sym_comment, + sym_documentation_comment, + [126513] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(2694), 1, + sym_nullable_type, + STATE(3296), 1, + sym_type_bound, + ACTIONS(5492), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2505), 2, + sym_comment, + sym_documentation_comment, + [126549] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5464), 1, + anon_sym_DQUOTE, + STATE(2506), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5462), 5, + sym__template_chars_double, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [126579] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2314), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2507), 2, + sym_comment, + sym_documentation_comment, + [126617] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5496), 1, + anon_sym_async, + STATE(2508), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5494), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [126647] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2343), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2509), 2, + sym_comment, + sym_documentation_comment, + [126685] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2348), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2510), 2, + sym_comment, + sym_documentation_comment, + [126723] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5500), 1, + anon_sym_LPAREN, + STATE(2511), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5498), 5, + anon_sym_final, + sym_void_type, + anon_sym_var, + anon_sym_Function, + sym_identifier, + [126753] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2273), 1, + anon_sym_LBRACE, + ACTIONS(2275), 1, + anon_sym_LBRACK, + ACTIONS(5502), 1, + anon_sym_RPAREN, + STATE(3515), 1, + sym_optional_formal_parameters, + STATE(2512), 2, + sym_comment, + sym_documentation_comment, + STATE(3481), 2, + sym__optional_postional_formal_parameters, + sym__named_formal_parameters, + [126789] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5310), 1, + anon_sym_SQUOTE, + STATE(2513), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 5, + sym__template_chars_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [126819] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5506), 1, + anon_sym_SQUOTE, + STATE(2514), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5504), 5, + sym__template_chars_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [126849] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5510), 1, + anon_sym_async, + STATE(2515), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5508), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [126879] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1622), 1, + sym__semicolon, + STATE(2576), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2516), 2, + sym_comment, + sym_documentation_comment, + [126915] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(3432), 1, + sym__formal_parameter_part, + STATE(2517), 2, + sym_comment, + sym_documentation_comment, + [126953] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5310), 1, + anon_sym_DQUOTE, + STATE(2518), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 5, + sym__template_chars_double, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [126983] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5512), 1, + anon_sym_DQUOTE, + STATE(2519), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5514), 5, + sym__template_chars_double, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [127013] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5518), 1, + anon_sym_async, + STATE(2520), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5516), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127043] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2521), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5284), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [127071] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1608), 1, + sym__semicolon, + STATE(2516), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2522), 2, + sym_comment, + sym_documentation_comment, + [127107] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5512), 1, + anon_sym_SQUOTE, + STATE(2523), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5514), 5, + sym__template_chars_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE_SQUOTE_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [127137] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2524), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5520), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [127165] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5524), 1, + anon_sym_async, + STATE(2525), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5522), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127195] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2778), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2526), 2, + sym_comment, + sym_documentation_comment, + [127233] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2527), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5216), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [127261] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2789), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2528), 2, + sym_comment, + sym_documentation_comment, + [127299] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2448), 1, + anon_sym_LBRACK, + ACTIONS(5442), 1, + sym_identifier, + ACTIONS(5444), 1, + anon_sym_QMARK, + STATE(829), 1, + sym_cascade_selector, + STATE(1196), 1, + sym_index_selector, + STATE(3047), 1, + sym_nullable_selector, + STATE(2529), 2, + sym_comment, + sym_documentation_comment, + [127337] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 1, + sym_type_parameters, + STATE(2980), 1, + sym__formal_parameter_part, + STATE(2530), 2, + sym_comment, + sym_documentation_comment, + [127375] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2531), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5386), 6, + sym__template_chars_double_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [127403] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(2652), 1, + sym_nullable_type, + STATE(3137), 1, + sym_type_bound, + ACTIONS(5526), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2532), 2, + sym_comment, + sym_documentation_comment, + [127439] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(5161), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2642), 1, + sym_enum_constant, + STATE(3500), 1, + sym__metadata, + STATE(2533), 2, + sym_comment, + sym_documentation_comment, + [127477] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2534), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4708), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [127505] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(2663), 1, + sym_nullable_type, + STATE(3140), 1, + sym_type_bound, + ACTIONS(5528), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2535), 2, + sym_comment, + sym_documentation_comment, + [127541] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2536), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4710), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [127569] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2319), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2537), 2, + sym_comment, + sym_documentation_comment, + [127607] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1608), 1, + sym__semicolon, + STATE(2576), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2538), 2, + sym_comment, + sym_documentation_comment, + [127643] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5532), 1, + anon_sym_async, + STATE(2539), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5530), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127673] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(119), 1, + anon_sym_BANG, + ACTIONS(5536), 1, + anon_sym_LPAREN, + STATE(2659), 1, + sym__exclamation_operator, + STATE(2540), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5534), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [127707] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5540), 1, + anon_sym_DOT, + STATE(2541), 3, + sym_comment, + sym_documentation_comment, + aux_sym_factory_constructor_signature_repeat1, + ACTIONS(5538), 4, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_EQ, + [127737] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5545), 1, + anon_sym_async, + STATE(2542), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5543), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127767] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2070), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2773), 1, + sym__formal_parameter_part, + STATE(2898), 1, + sym_type_parameters, + STATE(2543), 2, + sym_comment, + sym_documentation_comment, + [127805] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2544), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 6, + sym__template_chars_single_single, + sym__template_chars_raw_slash, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [127833] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5549), 1, + anon_sym_SEMI, + ACTIONS(5551), 1, + anon_sym_async, + STATE(2545), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5547), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127865] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5016), 1, + anon_sym_SEMI, + ACTIONS(5018), 1, + anon_sym_async, + STATE(2546), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5012), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127897] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5555), 1, + anon_sym_async, + STATE(2547), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5553), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [127927] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1572), 1, + sym__semicolon, + STATE(2576), 1, + aux_sym_library_export_repeat1, + STATE(2982), 1, + sym_combinator, + ACTIONS(5184), 2, + anon_sym_show, + anon_sym_hide, + STATE(2548), 2, + sym_comment, + sym_documentation_comment, + [127963] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(143), 1, + anon_sym_AT, + ACTIONS(5161), 1, + sym_identifier, + STATE(1329), 1, + aux_sym__metadata_repeat1, + STATE(1415), 1, + sym_annotation, + STATE(2756), 1, + sym_enum_constant, + STATE(3500), 1, + sym__metadata, + STATE(2549), 2, + sym_comment, + sym_documentation_comment, + [128001] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2550), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5557), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [128029] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2551), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5559), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [128057] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5563), 1, + anon_sym_async, + STATE(2552), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5561), 5, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [128087] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5448), 1, + anon_sym_DQUOTE, + STATE(2553), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5446), 5, + sym__template_chars_double, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [128117] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5565), 1, + anon_sym_DQUOTE, + STATE(2554), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5567), 5, + sym__template_chars_double, + anon_sym_SQUOTE, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [128147] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2555), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5569), 6, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ, + [128175] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(971), 1, + anon_sym_case, + ACTIONS(4748), 1, + sym_identifier, + ACTIONS(5571), 1, + anon_sym_default, + STATE(426), 1, + sym_case_builtin, + STATE(2595), 1, + aux_sym_switch_statement_case_repeat1, + STATE(2997), 1, + sym_label, + STATE(2556), 2, + sym_comment, + sym_documentation_comment, + [128213] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5573), 1, + sym_identifier, + ACTIONS(5575), 1, + anon_sym_new, + STATE(1225), 1, + sym__new_builtin, + STATE(2129), 1, + sym__identifier_or_new, + STATE(3359), 1, + sym__type_name, + STATE(2557), 2, + sym_comment, + sym_documentation_comment, + [128248] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2562), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(2558), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5577), 3, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_EQ, + [128279] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5583), 1, + anon_sym_COMMA, + ACTIONS(5581), 3, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_implements, + STATE(2559), 3, + sym_comment, + sym_documentation_comment, + aux_sym__type_not_void_list_repeat1, + [128308] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2541), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(3510), 1, + sym_formal_parameter_list, + STATE(2560), 2, + sym_comment, + sym_documentation_comment, + [128343] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5586), 1, + sym_identifier, + ACTIONS(5588), 1, + anon_sym_on, + ACTIONS(5590), 1, + anon_sym_type, + STATE(3421), 1, + sym_type_parameters, + STATE(2561), 2, + sym_comment, + sym_documentation_comment, + [128378] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2541), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(2562), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5592), 3, + anon_sym_RPAREN, + anon_sym_SEMI, + anon_sym_EQ_EQ, + [128409] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1766), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3109), 1, + sym_interfaces, + STATE(2563), 2, + sym_comment, + sym_documentation_comment, + [128444] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1809), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3100), 1, + sym_interfaces, + STATE(2564), 2, + sym_comment, + sym_documentation_comment, + [128479] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5594), 1, + sym_identifier, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + ACTIONS(5254), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2565), 2, + sym_comment, + sym_documentation_comment, + [128510] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5597), 1, + sym_identifier, + ACTIONS(5599), 1, + anon_sym_on, + ACTIONS(5601), 1, + anon_sym_type, + STATE(3406), 1, + sym_type_parameters, + STATE(2566), 2, + sym_comment, + sym_documentation_comment, + [128545] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1804), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3057), 1, + sym_interfaces, + STATE(2567), 2, + sym_comment, + sym_documentation_comment, + [128580] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1741), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3058), 1, + sym_interfaces, + STATE(2568), 2, + sym_comment, + sym_documentation_comment, + [128615] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(971), 1, + anon_sym_case, + ACTIONS(4748), 1, + sym_identifier, + STATE(426), 1, + sym_case_builtin, + STATE(2595), 1, + aux_sym_switch_statement_case_repeat1, + STATE(2997), 1, + sym_label, + STATE(2569), 2, + sym_comment, + sym_documentation_comment, + [128650] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1800), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(3287), 1, + sym_interfaces, + STATE(2570), 2, + sym_comment, + sym_documentation_comment, + [128685] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5573), 1, + sym_identifier, + ACTIONS(5603), 1, + anon_sym_new, + STATE(2125), 1, + sym__new_builtin, + STATE(2129), 1, + sym__identifier_or_new, + STATE(3359), 1, + sym__type_name, + STATE(2571), 2, + sym_comment, + sym_documentation_comment, + [128720] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4966), 1, + anon_sym_COMMA, + STATE(2584), 1, + aux_sym__identifier_list_repeat1, + STATE(2572), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5605), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [128751] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5609), 1, + anon_sym_COMMA, + STATE(2559), 1, + aux_sym__type_not_void_list_repeat1, + STATE(2573), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5607), 3, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_implements, + [128782] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2620), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(3159), 1, + sym_formal_parameter_list, + STATE(2574), 2, + sym_comment, + sym_documentation_comment, + [128817] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2592), 1, + sym_representation_declaration, + STATE(2713), 1, + sym_type_parameters, + STATE(2575), 2, + sym_comment, + sym_documentation_comment, + [128852] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5615), 1, + anon_sym_SEMI, + STATE(2982), 1, + sym_combinator, + ACTIONS(5617), 2, + anon_sym_show, + anon_sym_hide, + STATE(2576), 3, + sym_comment, + sym_documentation_comment, + aux_sym_library_export_repeat1, + [128883] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2577), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5462), 5, + sym__template_chars_single_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [128910] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5609), 1, + anon_sym_COMMA, + STATE(2573), 1, + aux_sym__type_not_void_list_repeat1, + STATE(2578), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5620), 3, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_implements, + [128941] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2579), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5622), 5, + anon_sym_as, + anon_sym_SEMI, + anon_sym_if, + anon_sym_show, + anon_sym_hide, + [128968] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1784), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3128), 1, + sym_interfaces, + STATE(2580), 2, + sym_comment, + sym_documentation_comment, + [129003] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1796), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(3133), 1, + sym_interfaces, + STATE(2581), 2, + sym_comment, + sym_documentation_comment, + [129038] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5624), 1, + anon_sym_COLON, + STATE(543), 1, + sym__semicolon, + ACTIONS(5466), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(2582), 2, + sym_comment, + sym_documentation_comment, + [129071] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(5628), 1, + anon_sym_RPAREN, + STATE(194), 1, + sym__semicolon, + STATE(2800), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2583), 2, + sym_comment, + sym_documentation_comment, + [129106] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4966), 1, + anon_sym_COMMA, + STATE(2602), 1, + aux_sym__identifier_list_repeat1, + STATE(2584), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5630), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [129137] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5349), 1, + sym_identifier, + STATE(2509), 2, + sym__get, + sym__set, + STATE(2585), 2, + sym_comment, + sym_documentation_comment, + [129170] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1765), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3294), 1, + sym_interfaces, + STATE(2586), 2, + sym_comment, + sym_documentation_comment, + [129205] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1802), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3107), 1, + sym_interfaces, + STATE(2587), 2, + sym_comment, + sym_documentation_comment, + [129240] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1805), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3152), 1, + sym_interfaces, + STATE(2588), 2, + sym_comment, + sym_documentation_comment, + [129275] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2560), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(3419), 1, + sym_formal_parameter_list, + STATE(2589), 2, + sym_comment, + sym_documentation_comment, + [129310] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2580), 1, + sym_representation_declaration, + STATE(2922), 1, + sym_type_parameters, + STATE(2590), 2, + sym_comment, + sym_documentation_comment, + [129345] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2598), 1, + sym_representation_declaration, + STATE(2862), 1, + sym_type_parameters, + STATE(2591), 2, + sym_comment, + sym_documentation_comment, + [129380] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1812), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3184), 1, + sym_interfaces, + STATE(2592), 2, + sym_comment, + sym_documentation_comment, + [129415] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2372), 1, + sym_formal_parameter_list, + STATE(2541), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(2593), 2, + sym_comment, + sym_documentation_comment, + [129450] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2594), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5538), 5, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT, + anon_sym_SEMI, + anon_sym_EQ_EQ, + [129477] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5632), 1, + sym_identifier, + STATE(2997), 1, + sym_label, + ACTIONS(5635), 2, + anon_sym_default, + anon_sym_case, + STATE(2595), 3, + sym_comment, + sym_documentation_comment, + aux_sym_switch_statement_case_repeat1, + [129508] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2596), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5637), 5, + sym__template_chars_double_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [129535] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(5639), 1, + anon_sym_RPAREN, + STATE(190), 1, + sym__semicolon, + STATE(2871), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2597), 2, + sym_comment, + sym_documentation_comment, + [129570] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1770), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3252), 1, + sym_interfaces, + STATE(2598), 2, + sym_comment, + sym_documentation_comment, + [129605] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5468), 1, + anon_sym_COLON, + STATE(2599), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5466), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [129634] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4992), 1, + anon_sym_LPAREN, + ACTIONS(5641), 1, + anon_sym_class, + STATE(2600), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4990), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [129665] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1749), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3267), 1, + sym_interfaces, + STATE(2601), 2, + sym_comment, + sym_documentation_comment, + [129700] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5643), 1, + anon_sym_COMMA, + ACTIONS(5646), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + STATE(2602), 3, + sym_comment, + sym_documentation_comment, + aux_sym__identifier_list_repeat1, + [129729] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2603), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5446), 5, + sym__template_chars_double_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [129756] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(5648), 1, + sym_identifier, + STATE(3530), 1, + sym_this, + STATE(3537), 1, + sym_super, + STATE(2604), 2, + sym_comment, + sym_documentation_comment, + [129791] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(5652), 1, + anon_sym_EQ, + ACTIONS(5654), 1, + anon_sym_SEMI, + ACTIONS(5656), 1, + anon_sym_in, + STATE(2785), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(2605), 2, + sym_comment, + sym_documentation_comment, + [129826] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5658), 1, + sym_identifier, + STATE(2451), 1, + sym__get, + STATE(2452), 1, + sym__set, + STATE(2606), 2, + sym_comment, + sym_documentation_comment, + [129861] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1776), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(3093), 1, + sym_interfaces, + STATE(2607), 2, + sym_comment, + sym_documentation_comment, + [129896] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1759), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3314), 1, + sym_interfaces, + STATE(2608), 2, + sym_comment, + sym_documentation_comment, + [129931] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1814), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3208), 1, + sym_interfaces, + STATE(2609), 2, + sym_comment, + sym_documentation_comment, + [129966] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2610), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5660), 5, + anon_sym_as, + anon_sym_SEMI, + anon_sym_if, + anon_sym_show, + anon_sym_hide, + [129993] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(163), 1, + anon_sym_this, + ACTIONS(165), 1, + anon_sym_super, + ACTIONS(5662), 1, + sym_identifier, + STATE(3530), 1, + sym_this, + STATE(3537), 1, + sym_super, + STATE(2611), 2, + sym_comment, + sym_documentation_comment, + [130028] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2612), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5446), 5, + sym__template_chars_single_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130055] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2613), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5462), 5, + sym__template_chars_double_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130082] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2614), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 5, + sym__template_chars_single_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130109] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(47), 1, + anon_sym_get, + ACTIONS(61), 1, + anon_sym_set, + ACTIONS(5658), 1, + sym_identifier, + STATE(2452), 1, + sym__set, + STATE(2489), 1, + sym__get, + STATE(2615), 2, + sym_comment, + sym_documentation_comment, + [130144] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2718), 2, + anon_sym_LPAREN, + anon_sym_DOT, + STATE(2616), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4379), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [130173] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5664), 1, + anon_sym_export, + ACTIONS(5666), 1, + anon_sym_import, + STATE(1618), 1, + sym_import_specification, + STATE(1847), 1, + sym__export, + STATE(1866), 1, + sym__import, + STATE(2617), 2, + sym_comment, + sym_documentation_comment, + [130208] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2618), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5514), 5, + sym__template_chars_single_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130235] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1782), 1, + sym_enum_body, + STATE(2049), 1, + sym__implements, + STATE(3139), 1, + sym_interfaces, + STATE(2619), 2, + sym_comment, + sym_documentation_comment, + [130270] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2541), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(3048), 1, + sym_formal_parameter_list, + STATE(2620), 2, + sym_comment, + sym_documentation_comment, + [130305] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5579), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2422), 1, + sym_formal_parameter_list, + STATE(2593), 1, + aux_sym_factory_constructor_signature_repeat1, + STATE(2621), 2, + sym_comment, + sym_documentation_comment, + [130340] = 11, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + ACTIONS(4670), 1, + anon_sym_implements, + STATE(1740), 1, + sym_class_body, + STATE(2049), 1, + sym__implements, + STATE(3131), 1, + sym_interfaces, + STATE(2622), 2, + sym_comment, + sym_documentation_comment, + [130375] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5551), 1, + anon_sym_async, + STATE(2623), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5547), 4, + anon_sym_LBRACE, + anon_sym_EQ_GT, + anon_sym_async_STAR, + anon_sym_sync_STAR, + [130404] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2624), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5312), 5, + sym__template_chars_double_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130431] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2625), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5514), 5, + sym__template_chars_double_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130458] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2626), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5668), 5, + sym__template_chars_single_single, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_DOLLAR, + sym__unused_escape_sequence, + [130485] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5670), 1, + sym_identifier, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + ACTIONS(5674), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2627), 2, + sym_comment, + sym_documentation_comment, + [130516] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2409), 1, + anon_sym_Function, + STATE(758), 1, + sym__function_builtin_identifier, + STATE(765), 1, + aux_sym__function_type_tails, + STATE(836), 1, + sym__function_type_tail, + STATE(2628), 2, + sym_comment, + sym_documentation_comment, + [130548] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4403), 1, + anon_sym_DOT, + STATE(999), 1, + sym_index_selector, + STATE(1026), 1, + sym_unconditional_assignable_selector, + STATE(2629), 2, + sym_comment, + sym_documentation_comment, + [130580] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5676), 1, + sym_identifier, + STATE(2125), 1, + sym__new_builtin, + STATE(2732), 1, + sym__identifier_or_new, + STATE(2630), 2, + sym_comment, + sym_documentation_comment, + [130612] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2631), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5108), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [130638] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(5678), 1, + sym_identifier, + STATE(3277), 1, + sym_factory_constructor_signature, + STATE(3545), 1, + sym__factory, + STATE(2632), 2, + sym_comment, + sym_documentation_comment, + [130670] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5680), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(5682), 2, + anon_sym_COLON, + anon_sym_EQ, + STATE(2633), 2, + sym_comment, + sym_documentation_comment, + [130698] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5684), 1, + anon_sym_Function, + STATE(1702), 1, + sym__function_type_tail, + STATE(2161), 1, + sym__function_builtin_identifier, + STATE(2186), 1, + aux_sym__function_type_tails, + STATE(2634), 2, + sym_comment, + sym_documentation_comment, + [130730] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(1295), 1, + sym_arguments, + STATE(3110), 1, + sym__dot_identifier, + STATE(2635), 2, + sym_comment, + sym_documentation_comment, + [130762] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2636), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5688), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_EQ, + [130788] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2637), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5691), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_EQ, + [130814] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4399), 1, + anon_sym_LBRACK, + ACTIONS(4403), 1, + anon_sym_DOT, + STATE(970), 1, + sym_unconditional_assignable_selector, + STATE(999), 1, + sym_index_selector, + STATE(2638), 2, + sym_comment, + sym_documentation_comment, + [130846] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(1119), 1, + sym_arguments, + STATE(3203), 1, + sym__dot_identifier, + STATE(2639), 2, + sym_comment, + sym_documentation_comment, + [130878] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5694), 1, + anon_sym_COMMA, + STATE(184), 1, + sym__semicolon, + STATE(2681), 1, + aux_sym__for_loop_parts_repeat1, + STATE(2640), 2, + sym_comment, + sym_documentation_comment, + [130910] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2082), 1, + anon_sym_LBRACK, + ACTIONS(3394), 1, + anon_sym_DOT, + STATE(844), 1, + sym_index_selector, + STATE(847), 1, + sym_unconditional_assignable_selector, + STATE(2641), 2, + sym_comment, + sym_documentation_comment, + [130942] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5696), 1, + anon_sym_RBRACE, + ACTIONS(5698), 1, + anon_sym_COMMA, + ACTIONS(5700), 1, + anon_sym_SEMI, + STATE(2664), 1, + aux_sym_enum_body_repeat1, + STATE(2642), 2, + sym_comment, + sym_documentation_comment, + [130974] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5702), 1, + anon_sym_EQ, + STATE(2040), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2643), 2, + sym_comment, + sym_documentation_comment, + [131006] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(961), 1, + sym_arguments, + STATE(3092), 1, + sym__dot_identifier, + STATE(2644), 2, + sym_comment, + sym_documentation_comment, + [131038] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4423), 1, + anon_sym_DOT, + STATE(1162), 1, + sym_unconditional_assignable_selector, + STATE(1169), 1, + sym_index_selector, + STATE(2645), 2, + sym_comment, + sym_documentation_comment, + [131070] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(2391), 1, + sym_arguments, + STATE(3216), 1, + sym__dot_identifier, + STATE(2646), 2, + sym_comment, + sym_documentation_comment, + [131102] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2231), 1, + anon_sym_LBRACK, + ACTIONS(3342), 1, + anon_sym_DOT, + STATE(1037), 1, + sym_unconditional_assignable_selector, + STATE(1041), 1, + sym_index_selector, + STATE(2647), 2, + sym_comment, + sym_documentation_comment, + [131134] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5704), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(5706), 2, + anon_sym_COLON, + anon_sym_EQ, + STATE(2648), 2, + sym_comment, + sym_documentation_comment, + [131162] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4419), 1, + anon_sym_LBRACK, + ACTIONS(4423), 1, + anon_sym_DOT, + STATE(1169), 1, + sym_index_selector, + STATE(1172), 1, + sym_unconditional_assignable_selector, + STATE(2649), 2, + sym_comment, + sym_documentation_comment, + [131194] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2767), 1, + anon_sym_Function, + STATE(889), 1, + aux_sym__function_type_tails, + STATE(892), 1, + sym__function_builtin_identifier, + STATE(1062), 1, + sym__function_type_tail, + STATE(2650), 2, + sym_comment, + sym_documentation_comment, + [131226] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5710), 1, + anon_sym_when, + STATE(2651), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5708), 3, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + [131254] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(3108), 1, + sym_type_bound, + ACTIONS(5712), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2652), 2, + sym_comment, + sym_documentation_comment, + [131284] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5016), 1, + anon_sym_SEMI, + ACTIONS(5714), 1, + anon_sym_COLON, + STATE(2653), 2, + sym_comment, + sym_documentation_comment, + STATE(3559), 2, + sym_initializers, + sym_redirection, + [131314] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5718), 1, + anon_sym_RBRACE, + STATE(2654), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5716), 3, + anon_sym_default, + anon_sym_case, + sym_identifier, + [131342] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2655), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5646), 4, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [131368] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(2442), 1, + sym_arguments, + STATE(3227), 1, + sym__dot_identifier, + STATE(2656), 2, + sym_comment, + sym_documentation_comment, + [131400] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + ACTIONS(5720), 1, + anon_sym_DOT, + STATE(3249), 1, + sym_type_arguments, + STATE(2657), 2, + sym_comment, + sym_documentation_comment, + [131432] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5684), 1, + anon_sym_Function, + STATE(1481), 1, + sym__function_builtin_identifier, + STATE(1623), 1, + aux_sym__function_type_tails, + STATE(1702), 1, + sym__function_type_tail, + STATE(2658), 2, + sym_comment, + sym_documentation_comment, + [131464] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5724), 1, + anon_sym_LPAREN, + STATE(2659), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5722), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [131492] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2660), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5726), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [131518] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5728), 1, + anon_sym_COMMA, + ACTIONS(5731), 2, + anon_sym_RBRACK, + anon_sym_RPAREN, + STATE(2661), 3, + sym_comment, + sym_documentation_comment, + aux_sym_parameter_type_list_repeat1, + [131546] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3569), 1, + anon_sym_Function, + STATE(1452), 1, + sym__function_builtin_identifier, + STATE(1493), 1, + aux_sym__function_type_tails, + STATE(1635), 1, + sym__function_type_tail, + STATE(2662), 2, + sym_comment, + sym_documentation_comment, + [131578] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(3117), 1, + sym_type_bound, + ACTIONS(5733), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2663), 2, + sym_comment, + sym_documentation_comment, + [131608] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1887), 1, + anon_sym_RBRACE, + ACTIONS(5178), 1, + anon_sym_SEMI, + ACTIONS(5735), 1, + anon_sym_COMMA, + STATE(2671), 1, + aux_sym_enum_body_repeat1, + STATE(2664), 2, + sym_comment, + sym_documentation_comment, + [131640] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5737), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(5739), 2, + anon_sym_COLON, + anon_sym_EQ, + STATE(2665), 2, + sym_comment, + sym_documentation_comment, + [131668] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5741), 1, + sym_identifier, + STATE(2125), 1, + sym__new_builtin, + STATE(3052), 1, + sym__identifier_or_new, + STATE(2666), 2, + sym_comment, + sym_documentation_comment, + [131700] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2667), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5743), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [131726] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5603), 1, + anon_sym_new, + ACTIONS(5676), 1, + sym_identifier, + STATE(2125), 1, + sym__new_builtin, + STATE(2146), 1, + sym__identifier_or_new, + STATE(2668), 2, + sym_comment, + sym_documentation_comment, + [131758] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2669), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5745), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [131784] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(4680), 1, + anon_sym_EQ, + STATE(2040), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2670), 2, + sym_comment, + sym_documentation_comment, + [131816] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5749), 1, + anon_sym_COMMA, + ACTIONS(5747), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(2671), 3, + sym_comment, + sym_documentation_comment, + aux_sym_enum_body_repeat1, + [131844] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4668), 1, + anon_sym_with, + STATE(3312), 1, + sym_mixins, + ACTIONS(5752), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(2672), 2, + sym_comment, + sym_documentation_comment, + [131874] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2349), 1, + anon_sym_LBRACK, + ACTIONS(2354), 1, + anon_sym_DOT, + STATE(1206), 1, + sym_index_selector, + STATE(1217), 1, + sym_unconditional_assignable_selector, + STATE(2673), 2, + sym_comment, + sym_documentation_comment, + [131906] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5686), 1, + anon_sym_DOT, + ACTIONS(5754), 1, + anon_sym_LPAREN, + STATE(2140), 1, + sym_arguments, + STATE(3167), 1, + sym__dot_identifier, + STATE(2674), 2, + sym_comment, + sym_documentation_comment, + [131938] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(5652), 1, + anon_sym_EQ, + ACTIONS(5654), 1, + anon_sym_SEMI, + STATE(2785), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(2675), 2, + sym_comment, + sym_documentation_comment, + [131970] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + ACTIONS(5756), 1, + anon_sym_DOT, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(3290), 1, + sym_formal_parameter_list, + STATE(2676), 2, + sym_comment, + sym_documentation_comment, + [132002] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2677), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5758), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [132028] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5760), 1, + sym_identifier, + STATE(2125), 1, + sym__new_builtin, + STATE(2824), 1, + sym__identifier_or_new, + STATE(2678), 2, + sym_comment, + sym_documentation_comment, + [132060] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(1181), 1, + sym_arguments, + STATE(3170), 1, + sym__dot_identifier, + STATE(2679), 2, + sym_comment, + sym_documentation_comment, + [132092] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(1271), 1, + sym_arguments, + STATE(3113), 1, + sym__dot_identifier, + STATE(2680), 2, + sym_comment, + sym_documentation_comment, + [132124] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(5694), 1, + anon_sym_COMMA, + STATE(189), 1, + sym__semicolon, + STATE(2787), 1, + aux_sym__for_loop_parts_repeat1, + STATE(2681), 2, + sym_comment, + sym_documentation_comment, + [132156] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2682), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5581), 4, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_implements, + [132182] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2683), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5466), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [132208] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3444), 1, + anon_sym_Function, + STATE(1342), 1, + sym__function_builtin_identifier, + STATE(1383), 1, + aux_sym__function_type_tails, + STATE(1551), 1, + sym__function_type_tail, + STATE(2684), 2, + sym_comment, + sym_documentation_comment, + [132240] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5762), 1, + sym_identifier, + STATE(2685), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5764), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [132268] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5766), 1, + anon_sym_LBRACE, + ACTIONS(5768), 1, + anon_sym_catch, + STATE(490), 1, + sym_block, + STATE(3059), 1, + sym_catch_clause, + STATE(2686), 2, + sym_comment, + sym_documentation_comment, + [132300] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1719), 1, + anon_sym_factory, + ACTIONS(5678), 1, + sym_identifier, + STATE(3570), 1, + sym_factory_constructor_signature, + STATE(3584), 1, + sym__factory, + STATE(2687), 2, + sym_comment, + sym_documentation_comment, + [132332] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5762), 1, + sym_identifier, + STATE(2688), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5770), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [132360] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(933), 1, + sym_hex_integer_literal, + STATE(2150), 1, + sym__numeric_literal, + ACTIONS(931), 2, + sym_decimal_integer_literal, + sym_decimal_floating_point_literal, + STATE(2689), 2, + sym_comment, + sym_documentation_comment, + [132390] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2690), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5772), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [132416] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2691), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5774), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [132442] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3316), 1, + anon_sym_Function, + STATE(1275), 1, + sym__function_builtin_identifier, + STATE(1330), 1, + aux_sym__function_type_tails, + STATE(1440), 1, + sym__function_type_tail, + STATE(2692), 2, + sym_comment, + sym_documentation_comment, + [132474] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5778), 1, + anon_sym_LPAREN, + STATE(2693), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5776), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [132502] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(3135), 1, + sym_type_bound, + ACTIONS(5780), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2694), 2, + sym_comment, + sym_documentation_comment, + [132532] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4520), 1, + anon_sym_LPAREN, + ACTIONS(4522), 1, + anon_sym_DOT, + STATE(3201), 1, + sym_type_arguments, + STATE(2695), 2, + sym_comment, + sym_documentation_comment, + [132564] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + ACTIONS(5686), 1, + anon_sym_DOT, + STATE(997), 1, + sym_arguments, + STATE(3265), 1, + sym__dot_identifier, + STATE(2696), 2, + sym_comment, + sym_documentation_comment, + [132596] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5784), 1, + anon_sym_LPAREN, + STATE(2697), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5782), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [132624] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5788), 1, + anon_sym_else, + STATE(2698), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5786), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + [132652] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4389), 1, + anon_sym_LBRACK, + ACTIONS(4395), 1, + anon_sym_DOT, + STATE(1251), 1, + sym_unconditional_assignable_selector, + STATE(1304), 1, + sym_index_selector, + STATE(2699), 2, + sym_comment, + sym_documentation_comment, + [132684] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5792), 1, + anon_sym_LPAREN, + STATE(2700), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5790), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [132712] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5794), 1, + sym_identifier, + STATE(2125), 1, + sym__new_builtin, + STATE(3052), 1, + sym__identifier_or_new, + STATE(2701), 2, + sym_comment, + sym_documentation_comment, + [132744] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5798), 1, + anon_sym_LPAREN, + STATE(2702), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5796), 3, + sym_void_type, + anon_sym_Function, + sym_identifier, + [132772] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4851), 1, + anon_sym_extends, + STATE(3140), 1, + sym_type_bound, + ACTIONS(5528), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(2703), 2, + sym_comment, + sym_documentation_comment, + [132802] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4670), 1, + anon_sym_implements, + ACTIONS(5800), 1, + anon_sym_SEMI, + STATE(2049), 1, + sym__implements, + STATE(3380), 1, + sym_interfaces, + STATE(2704), 2, + sym_comment, + sym_documentation_comment, + [132834] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5804), 1, + anon_sym_COMMA, + ACTIONS(5802), 2, + anon_sym_RBRACE, + anon_sym_RBRACK, + STATE(2705), 3, + sym_comment, + sym_documentation_comment, + aux_sym_list_literal_repeat1, + [132862] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2706), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5807), 4, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_else, + [132888] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5811), 1, + anon_sym_else, + STATE(2707), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5809), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + [132916] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3785), 1, + anon_sym_RPAREN, + ACTIONS(5813), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2708), 2, + sym_comment, + sym_documentation_comment, + [132945] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5815), 1, + sym_identifier, + STATE(3629), 1, + sym__new_builtin, + STATE(2709), 2, + sym_comment, + sym_documentation_comment, + [132974] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(650), 1, + anon_sym_RBRACE, + ACTIONS(5817), 1, + anon_sym_COMMA, + STATE(2933), 1, + aux_sym_map_pattern_repeat1, + STATE(2710), 2, + sym_comment, + sym_documentation_comment, + [133003] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(993), 1, + anon_sym_RBRACK, + ACTIONS(5819), 1, + anon_sym_COMMA, + STATE(2945), 1, + aux_sym_list_pattern_repeat1, + STATE(2711), 2, + sym_comment, + sym_documentation_comment, + [133032] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(5821), 1, + anon_sym_SEMI, + STATE(2714), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(2712), 2, + sym_comment, + sym_documentation_comment, + [133061] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2588), 1, + sym_representation_declaration, + STATE(2713), 2, + sym_comment, + sym_documentation_comment, + [133090] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5823), 1, + anon_sym_COMMA, + ACTIONS(5826), 1, + anon_sym_SEMI, + STATE(2714), 3, + sym_comment, + sym_documentation_comment, + aux_sym_initialized_identifier_list_repeat1, + [133117] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1031), 1, + anon_sym_RPAREN, + ACTIONS(5828), 1, + anon_sym_COMMA, + STATE(2983), 1, + aux_sym_record_pattern_repeat1, + STATE(2715), 2, + sym_comment, + sym_documentation_comment, + [133146] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1031), 1, + anon_sym_RPAREN, + ACTIONS(5828), 1, + anon_sym_COMMA, + STATE(2821), 1, + aux_sym_record_pattern_repeat1, + STATE(2716), 2, + sym_comment, + sym_documentation_comment, + [133175] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5575), 1, + anon_sym_new, + ACTIONS(5830), 1, + sym_identifier, + STATE(923), 1, + sym__new_builtin, + STATE(2717), 2, + sym_comment, + sym_documentation_comment, + [133204] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5832), 1, + sym_identifier, + ACTIONS(5674), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2718), 2, + sym_comment, + sym_documentation_comment, + [133231] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5835), 1, + anon_sym_RBRACE, + ACTIONS(5837), 1, + anon_sym_COMMA, + STATE(2719), 3, + sym_comment, + sym_documentation_comment, + aux_sym_named_parameter_types_repeat1, + [133258] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5840), 1, + anon_sym_COMMA, + ACTIONS(5843), 1, + anon_sym_SEMI, + STATE(2720), 3, + sym_comment, + sym_documentation_comment, + aux_sym_static_final_declaration_list_repeat1, + [133285] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(5845), 1, + anon_sym_on, + STATE(3425), 1, + sym_type_parameters, + STATE(2721), 2, + sym_comment, + sym_documentation_comment, + [133314] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(5849), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2722), 2, + sym_comment, + sym_documentation_comment, + [133343] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4238), 1, + anon_sym_RBRACE, + ACTIONS(5851), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2723), 2, + sym_comment, + sym_documentation_comment, + [133372] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2724), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5853), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [133397] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1939), 1, + anon_sym_QMARK, + ACTIONS(5855), 1, + sym_identifier, + STATE(2535), 1, + sym_nullable_type, + STATE(2725), 2, + sym_comment, + sym_documentation_comment, + [133426] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5857), 1, + anon_sym_RBRACE, + ACTIONS(5859), 1, + anon_sym_COMMA, + STATE(2954), 1, + aux_sym__named_formal_parameters_repeat1, + STATE(2726), 2, + sym_comment, + sym_documentation_comment, + [133455] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5861), 1, + sym_identifier, + STATE(3303), 1, + sym__new_builtin, + STATE(2727), 2, + sym_comment, + sym_documentation_comment, + [133484] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5865), 1, + anon_sym_EQ, + ACTIONS(5863), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(2728), 2, + sym_comment, + sym_documentation_comment, + [133511] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5867), 1, + anon_sym_COMMA, + ACTIONS(5869), 1, + anon_sym_RBRACK, + STATE(2965), 1, + aux_sym__optional_postional_formal_parameters_repeat1, + STATE(2729), 2, + sym_comment, + sym_documentation_comment, + [133540] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2730), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4481), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [133565] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5871), 1, + anon_sym_COMMA, + ACTIONS(5874), 1, + anon_sym_GT, + STATE(2731), 3, + sym_comment, + sym_documentation_comment, + aux_sym_type_arguments_repeat1, + [133592] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(3319), 1, + sym_formal_parameter_list, + STATE(2732), 2, + sym_comment, + sym_documentation_comment, + [133621] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4904), 1, + anon_sym_EQ, + ACTIONS(4902), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(2733), 2, + sym_comment, + sym_documentation_comment, + [133648] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5876), 1, + sym_identifier, + STATE(3053), 1, + sym__new_builtin, + STATE(2734), 2, + sym_comment, + sym_documentation_comment, + [133677] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4171), 1, + anon_sym_RBRACE, + ACTIONS(5878), 1, + anon_sym_COMMA, + STATE(2719), 1, + aux_sym_named_parameter_types_repeat1, + STATE(2735), 2, + sym_comment, + sym_documentation_comment, + [133706] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5880), 1, + sym_identifier, + STATE(3187), 1, + sym_dotted_identifier_list, + STATE(3556), 1, + sym_uri_test, + STATE(2736), 2, + sym_comment, + sym_documentation_comment, + [133735] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4224), 1, + anon_sym_RBRACK, + ACTIONS(5882), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2737), 2, + sym_comment, + sym_documentation_comment, + [133764] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2738), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5731), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [133789] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3347), 1, + sym_initialized_identifier_list, + STATE(2739), 2, + sym_comment, + sym_documentation_comment, + [133818] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3182), 1, + sym_initialized_identifier_list, + STATE(2740), 2, + sym_comment, + sym_documentation_comment, + [133847] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(5888), 1, + anon_sym_GT, + STATE(3042), 1, + aux_sym_type_parameters_repeat1, + STATE(2741), 2, + sym_comment, + sym_documentation_comment, + [133876] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2742), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5890), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [133901] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5892), 1, + anon_sym_COMMA, + ACTIONS(5895), 1, + anon_sym_RPAREN, + STATE(2996), 1, + aux_sym__normal_formal_parameters_repeat1, + STATE(2743), 2, + sym_comment, + sym_documentation_comment, + [133930] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2744), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4489), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [133955] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(620), 1, + anon_sym_RBRACE, + ACTIONS(5897), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2745), 2, + sym_comment, + sym_documentation_comment, + [133984] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4226), 1, + anon_sym_RBRACE, + ACTIONS(5899), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2746), 2, + sym_comment, + sym_documentation_comment, + [134013] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(560), 1, + anon_sym_RBRACK, + ACTIONS(5901), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2747), 2, + sym_comment, + sym_documentation_comment, + [134042] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4226), 1, + anon_sym_RBRACE, + ACTIONS(5899), 1, + anon_sym_COMMA, + STATE(2723), 1, + aux_sym_record_type_repeat2, + STATE(2748), 2, + sym_comment, + sym_documentation_comment, + [134071] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(620), 1, + anon_sym_RBRACE, + ACTIONS(5897), 1, + anon_sym_COMMA, + STATE(2833), 1, + aux_sym_list_literal_repeat1, + STATE(2749), 2, + sym_comment, + sym_documentation_comment, + [134100] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(560), 1, + anon_sym_RBRACK, + ACTIONS(5901), 1, + anon_sym_COMMA, + STATE(2834), 1, + aux_sym_list_literal_repeat1, + STATE(2750), 2, + sym_comment, + sym_documentation_comment, + [134129] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5903), 1, + anon_sym_COMMA, + ACTIONS(5906), 1, + anon_sym_RPAREN, + STATE(2751), 3, + sym_comment, + sym_documentation_comment, + aux_sym__argument_list_repeat1, + [134156] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5908), 1, + anon_sym_RBRACE, + ACTIONS(5910), 1, + anon_sym_COMMA, + STATE(2838), 1, + aux_sym_list_literal_repeat1, + STATE(2752), 2, + sym_comment, + sym_documentation_comment, + [134185] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5908), 1, + anon_sym_RBRACK, + ACTIONS(5912), 1, + anon_sym_COMMA, + STATE(2842), 1, + aux_sym_list_literal_repeat1, + STATE(2753), 2, + sym_comment, + sym_documentation_comment, + [134214] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2754), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5914), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [134239] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5916), 1, + sym_identifier, + STATE(3079), 1, + sym__new_builtin, + STATE(2755), 2, + sym_comment, + sym_documentation_comment, + [134268] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2756), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5747), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [134293] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5918), 1, + anon_sym_COMMA, + ACTIONS(5920), 1, + anon_sym_RPAREN, + STATE(2765), 1, + aux_sym_record_type_repeat1, + STATE(2757), 2, + sym_comment, + sym_documentation_comment, + [134322] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(5922), 1, + sym_identifier, + STATE(3095), 1, + sym__new_builtin, + STATE(2758), 2, + sym_comment, + sym_documentation_comment, + [134351] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2759), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5924), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [134376] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(5926), 1, + anon_sym_DOT, + STATE(932), 1, + sym_arguments, + STATE(2760), 2, + sym_comment, + sym_documentation_comment, + [134405] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5087), 1, + anon_sym_class, + ACTIONS(5093), 1, + anon_sym_mixin, + STATE(3297), 1, + sym_mixin, + STATE(2761), 2, + sym_comment, + sym_documentation_comment, + [134434] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(538), 1, + anon_sym_RBRACK, + ACTIONS(5928), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2762), 2, + sym_comment, + sym_documentation_comment, + [134463] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5930), 1, + anon_sym_RBRACE, + ACTIONS(5932), 1, + anon_sym_COMMA, + STATE(2735), 1, + aux_sym_named_parameter_types_repeat1, + STATE(2763), 2, + sym_comment, + sym_documentation_comment, + [134492] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5934), 1, + anon_sym_COMMA, + ACTIONS(5936), 1, + anon_sym_RBRACK, + STATE(2737), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2764), 2, + sym_comment, + sym_documentation_comment, + [134521] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4246), 1, + anon_sym_RPAREN, + ACTIONS(5938), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2765), 2, + sym_comment, + sym_documentation_comment, + [134550] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1029), 1, + anon_sym_RBRACE, + ACTIONS(5940), 1, + anon_sym_COMMA, + STATE(2851), 1, + aux_sym_switch_expression_repeat1, + STATE(2766), 2, + sym_comment, + sym_documentation_comment, + [134579] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(5942), 1, + anon_sym_LBRACE, + ACTIONS(5944), 1, + aux_sym__sub_string_test_token1, + ACTIONS(5946), 1, + sym_identifier_dollar_escaped, + STATE(2767), 2, + sym_comment, + sym_documentation_comment, + [134608] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5948), 1, + anon_sym_COMMA, + ACTIONS(5950), 1, + anon_sym_SEMI, + STATE(2720), 1, + aux_sym_static_final_declaration_list_repeat1, + STATE(2768), 2, + sym_comment, + sym_documentation_comment, + [134637] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(5952), 1, + anon_sym_GT, + STATE(2780), 1, + aux_sym_type_parameters_repeat1, + STATE(2769), 2, + sym_comment, + sym_documentation_comment, + [134666] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2770), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5770), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [134691] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5954), 1, + sym_identifier, + STATE(2826), 1, + sym_static_final_declaration, + STATE(3062), 1, + sym_static_final_declaration_list, + STATE(2771), 2, + sym_comment, + sym_documentation_comment, + [134720] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(522), 1, + anon_sym_RBRACE, + ACTIONS(5956), 1, + anon_sym_COMMA, + STATE(3031), 1, + aux_sym_list_literal_repeat1, + STATE(2772), 2, + sym_comment, + sym_documentation_comment, + [134749] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5256), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2515), 1, + sym__native, + STATE(2773), 2, + sym_comment, + sym_documentation_comment, + [134778] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5264), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2542), 1, + sym__native, + STATE(2774), 2, + sym_comment, + sym_documentation_comment, + [134807] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5272), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2547), 1, + sym__native, + STATE(2775), 2, + sym_comment, + sym_documentation_comment, + [134836] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(5958), 1, + anon_sym_GT, + STATE(2790), 1, + aux_sym_type_arguments_repeat1, + STATE(2776), 2, + sym_comment, + sym_documentation_comment, + [134865] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5960), 1, + anon_sym_COMMA, + ACTIONS(5962), 1, + anon_sym_RPAREN, + STATE(2792), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2777), 2, + sym_comment, + sym_documentation_comment, + [134894] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5304), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2508), 1, + sym__native, + STATE(2778), 2, + sym_comment, + sym_documentation_comment, + [134923] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(538), 1, + anon_sym_RBRACK, + ACTIONS(5928), 1, + anon_sym_COMMA, + STATE(3033), 1, + aux_sym_list_literal_repeat1, + STATE(2779), 2, + sym_comment, + sym_documentation_comment, + [134952] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(5964), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(2780), 2, + sym_comment, + sym_documentation_comment, + [134981] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(552), 1, + anon_sym_RBRACE, + ACTIONS(5966), 1, + anon_sym_COMMA, + STATE(2794), 1, + aux_sym_list_literal_repeat1, + STATE(2781), 2, + sym_comment, + sym_documentation_comment, + [135010] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(554), 1, + anon_sym_RBRACK, + ACTIONS(5968), 1, + anon_sym_COMMA, + STATE(2795), 1, + aux_sym_list_literal_repeat1, + STATE(2782), 2, + sym_comment, + sym_documentation_comment, + [135039] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4228), 1, + anon_sym_RBRACE, + ACTIONS(5970), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2783), 2, + sym_comment, + sym_documentation_comment, + [135068] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(4522), 1, + anon_sym_DOT, + STATE(3395), 1, + sym_type_arguments, + STATE(2784), 2, + sym_comment, + sym_documentation_comment, + [135097] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(5972), 1, + anon_sym_SEMI, + STATE(2714), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(2785), 2, + sym_comment, + sym_documentation_comment, + [135126] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5974), 1, + anon_sym_RBRACE, + ACTIONS(5976), 1, + anon_sym_COMMA, + STATE(2786), 3, + sym_comment, + sym_documentation_comment, + aux_sym__named_formal_parameters_repeat1, + [135153] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5979), 1, + anon_sym_COMMA, + ACTIONS(5982), 1, + anon_sym_SEMI, + STATE(2787), 3, + sym_comment, + sym_documentation_comment, + aux_sym__for_loop_parts_repeat1, + [135180] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(5984), 1, + anon_sym_EQ_GT, + STATE(2441), 1, + sym_block, + STATE(2788), 2, + sym_comment, + sym_documentation_comment, + [135209] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5204), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2491), 1, + sym__native, + STATE(2789), 2, + sym_comment, + sym_documentation_comment, + [135238] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(5986), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2790), 2, + sym_comment, + sym_documentation_comment, + [135267] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3559), 1, + sym_initialized_identifier_list, + STATE(2791), 2, + sym_comment, + sym_documentation_comment, + [135296] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3775), 1, + anon_sym_RPAREN, + ACTIONS(5988), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2792), 2, + sym_comment, + sym_documentation_comment, + [135325] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(5990), 1, + anon_sym_RPAREN, + STATE(2881), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2793), 2, + sym_comment, + sym_documentation_comment, + [135354] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(556), 1, + anon_sym_RBRACE, + ACTIONS(5992), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2794), 2, + sym_comment, + sym_documentation_comment, + [135383] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(558), 1, + anon_sym_RBRACK, + ACTIONS(5994), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2795), 2, + sym_comment, + sym_documentation_comment, + [135412] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5996), 1, + anon_sym_COMMA, + ACTIONS(5998), 1, + anon_sym_RPAREN, + STATE(2978), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(2796), 2, + sym_comment, + sym_documentation_comment, + [135441] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6000), 1, + anon_sym_COMMA, + ACTIONS(6003), 1, + anon_sym_RBRACK, + STATE(2797), 3, + sym_comment, + sym_documentation_comment, + aux_sym__optional_postional_formal_parameters_repeat1, + [135468] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(556), 1, + anon_sym_RBRACE, + ACTIONS(5992), 1, + anon_sym_COMMA, + STATE(2809), 1, + aux_sym_list_literal_repeat1, + STATE(2798), 2, + sym_comment, + sym_documentation_comment, + [135497] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(558), 1, + anon_sym_RBRACK, + ACTIONS(5994), 1, + anon_sym_COMMA, + STATE(2810), 1, + aux_sym_list_literal_repeat1, + STATE(2799), 2, + sym_comment, + sym_documentation_comment, + [135526] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6005), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2800), 2, + sym_comment, + sym_documentation_comment, + [135555] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6007), 1, + anon_sym_RPAREN, + STATE(2887), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2801), 2, + sym_comment, + sym_documentation_comment, + [135584] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6009), 1, + sym_identifier, + ACTIONS(5674), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2802), 2, + sym_comment, + sym_documentation_comment, + [135611] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6011), 1, + sym_identifier, + ACTIONS(6013), 1, + anon_sym_new, + STATE(1247), 1, + sym__new_builtin, + STATE(2803), 2, + sym_comment, + sym_documentation_comment, + [135640] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(6015), 1, + anon_sym_DOT, + STATE(2365), 1, + sym_arguments, + STATE(2804), 2, + sym_comment, + sym_documentation_comment, + [135669] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5248), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2480), 1, + sym__native, + STATE(2805), 2, + sym_comment, + sym_documentation_comment, + [135698] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(512), 1, + anon_sym_RBRACE, + ACTIONS(6017), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2806), 2, + sym_comment, + sym_documentation_comment, + [135727] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(514), 1, + anon_sym_RBRACK, + ACTIONS(6019), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2807), 2, + sym_comment, + sym_documentation_comment, + [135756] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6021), 1, + anon_sym_RBRACE, + ACTIONS(6023), 1, + anon_sym_COMMA, + STATE(2816), 1, + aux_sym_switch_expression_repeat1, + STATE(2808), 2, + sym_comment, + sym_documentation_comment, + [135785] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(622), 1, + anon_sym_RBRACE, + ACTIONS(6025), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2809), 2, + sym_comment, + sym_documentation_comment, + [135814] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(562), 1, + anon_sym_RBRACK, + ACTIONS(6027), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2810), 2, + sym_comment, + sym_documentation_comment, + [135843] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(622), 1, + anon_sym_RBRACE, + ACTIONS(6025), 1, + anon_sym_COMMA, + STATE(2818), 1, + aux_sym_list_literal_repeat1, + STATE(2811), 2, + sym_comment, + sym_documentation_comment, + [135872] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(562), 1, + anon_sym_RBRACK, + ACTIONS(6027), 1, + anon_sym_COMMA, + STATE(2819), 1, + aux_sym_list_literal_repeat1, + STATE(2812), 2, + sym_comment, + sym_documentation_comment, + [135901] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3286), 1, + sym_initialized_identifier_list, + STATE(2813), 2, + sym_comment, + sym_documentation_comment, + [135930] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5218), 1, + anon_sym_SEMI, + ACTIONS(6029), 1, + anon_sym_COMMA, + STATE(2820), 1, + aux_sym_initializers_repeat1, + STATE(2814), 2, + sym_comment, + sym_documentation_comment, + [135959] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5224), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2520), 1, + sym__native, + STATE(2815), 2, + sym_comment, + sym_documentation_comment, + [135988] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1043), 1, + anon_sym_RBRACE, + ACTIONS(6031), 1, + anon_sym_COMMA, + STATE(2851), 1, + aux_sym_switch_expression_repeat1, + STATE(2816), 2, + sym_comment, + sym_documentation_comment, + [136017] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6033), 1, + anon_sym_COMMA, + ACTIONS(6035), 1, + anon_sym_RPAREN, + STATE(2939), 1, + aux_sym_record_type_repeat1, + STATE(2817), 2, + sym_comment, + sym_documentation_comment, + [136046] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(566), 1, + anon_sym_RBRACE, + ACTIONS(6037), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2818), 2, + sym_comment, + sym_documentation_comment, + [136075] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(568), 1, + anon_sym_RBRACK, + ACTIONS(6039), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2819), 2, + sym_comment, + sym_documentation_comment, + [136104] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5112), 1, + anon_sym_SEMI, + ACTIONS(6041), 1, + anon_sym_COMMA, + STATE(2820), 3, + sym_comment, + sym_documentation_comment, + aux_sym_initializers_repeat1, + [136131] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1027), 1, + anon_sym_RPAREN, + ACTIONS(6044), 1, + anon_sym_COMMA, + STATE(2983), 1, + aux_sym_record_pattern_repeat1, + STATE(2821), 2, + sym_comment, + sym_documentation_comment, + [136160] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(6046), 1, + anon_sym_DOT, + STATE(3333), 1, + sym_type_arguments, + STATE(2822), 2, + sym_comment, + sym_documentation_comment, + [136189] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2823), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6048), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [136214] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2363), 1, + sym_formal_parameter_list, + STATE(2824), 2, + sym_comment, + sym_documentation_comment, + [136243] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2825), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6050), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [136268] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5948), 1, + anon_sym_COMMA, + ACTIONS(6052), 1, + anon_sym_SEMI, + STATE(2768), 1, + aux_sym_static_final_declaration_list_repeat1, + STATE(2826), 2, + sym_comment, + sym_documentation_comment, + [136297] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4966), 1, + anon_sym_COMMA, + ACTIONS(6054), 1, + anon_sym_SEMI, + STATE(2602), 1, + aux_sym__identifier_list_repeat1, + STATE(2827), 2, + sym_comment, + sym_documentation_comment, + [136326] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4966), 1, + anon_sym_COMMA, + ACTIONS(4968), 1, + anon_sym_SEMI, + STATE(2827), 1, + aux_sym__identifier_list_repeat1, + STATE(2828), 2, + sym_comment, + sym_documentation_comment, + [136355] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(6056), 1, + anon_sym_DOT, + STATE(3357), 1, + sym_arguments, + STATE(2829), 2, + sym_comment, + sym_documentation_comment, + [136384] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + ACTIONS(6058), 1, + anon_sym_DOT, + STATE(2365), 1, + sym_arguments, + STATE(2830), 2, + sym_comment, + sym_documentation_comment, + [136413] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6060), 1, + anon_sym_RBRACE, + ACTIONS(6062), 1, + anon_sym_COMMA, + STATE(2831), 3, + sym_comment, + sym_documentation_comment, + aux_sym_record_type_repeat2, + [136440] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4222), 1, + anon_sym_RBRACE, + ACTIONS(6065), 1, + anon_sym_COMMA, + STATE(2746), 1, + aux_sym_record_type_repeat2, + STATE(2832), 2, + sym_comment, + sym_documentation_comment, + [136469] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(516), 1, + anon_sym_RBRACE, + ACTIONS(6067), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2833), 2, + sym_comment, + sym_documentation_comment, + [136498] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(518), 1, + anon_sym_RBRACK, + ACTIONS(6069), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2834), 2, + sym_comment, + sym_documentation_comment, + [136527] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2321), 1, + sym_formal_parameter_list, + STATE(2835), 2, + sym_comment, + sym_documentation_comment, + [136556] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3369), 1, + sym_initialized_identifier_list, + STATE(2836), 2, + sym_comment, + sym_documentation_comment, + [136585] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6071), 1, + anon_sym_COMMA, + ACTIONS(6073), 1, + anon_sym_RPAREN, + STATE(2841), 1, + aux_sym_record_type_repeat1, + STATE(2837), 2, + sym_comment, + sym_documentation_comment, + [136614] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(520), 1, + anon_sym_RBRACE, + ACTIONS(6075), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2838), 2, + sym_comment, + sym_documentation_comment, + [136643] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3062), 1, + sym_initialized_identifier_list, + STATE(2839), 2, + sym_comment, + sym_documentation_comment, + [136672] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(644), 1, + anon_sym_RPAREN, + ACTIONS(6077), 1, + anon_sym_COMMA, + STATE(2751), 1, + aux_sym__argument_list_repeat1, + STATE(2840), 2, + sym_comment, + sym_documentation_comment, + [136701] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4260), 1, + anon_sym_RPAREN, + ACTIONS(6079), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2841), 2, + sym_comment, + sym_documentation_comment, + [136730] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(520), 1, + anon_sym_RBRACK, + ACTIONS(6081), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2842), 2, + sym_comment, + sym_documentation_comment, + [136759] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(6083), 1, + anon_sym_LBRACE, + ACTIONS(6085), 1, + aux_sym__sub_string_test_token1, + ACTIONS(6087), 1, + sym_identifier_dollar_escaped, + STATE(2843), 2, + sym_comment, + sym_documentation_comment, + [136788] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5360), 1, + anon_sym_LBRACE, + ACTIONS(6089), 1, + anon_sym_EQ_GT, + STATE(959), 1, + sym_block, + STATE(2844), 2, + sym_comment, + sym_documentation_comment, + [136817] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(6091), 1, + sym_identifier, + STATE(3076), 1, + sym__new_builtin, + STATE(2845), 2, + sym_comment, + sym_documentation_comment, + [136846] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6093), 1, + anon_sym_GT, + STATE(2855), 1, + aux_sym_type_parameters_repeat1, + STATE(2846), 2, + sym_comment, + sym_documentation_comment, + [136875] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(520), 1, + anon_sym_RBRACE, + ACTIONS(6075), 1, + anon_sym_COMMA, + STATE(2951), 1, + aux_sym_list_literal_repeat1, + STATE(2847), 2, + sym_comment, + sym_documentation_comment, + [136904] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(520), 1, + anon_sym_RBRACK, + ACTIONS(6081), 1, + anon_sym_COMMA, + STATE(2953), 1, + aux_sym_list_literal_repeat1, + STATE(2848), 2, + sym_comment, + sym_documentation_comment, + [136933] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2849), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6095), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [136958] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5954), 1, + sym_identifier, + STATE(2826), 1, + sym_static_final_declaration, + STATE(3369), 1, + sym_static_final_declaration_list, + STATE(2850), 2, + sym_comment, + sym_documentation_comment, + [136987] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6097), 1, + anon_sym_RBRACE, + ACTIONS(6099), 1, + anon_sym_COMMA, + STATE(2851), 3, + sym_comment, + sym_documentation_comment, + aux_sym_switch_expression_repeat1, + [137014] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(6102), 1, + anon_sym_DOT, + STATE(932), 1, + sym_arguments, + STATE(2852), 2, + sym_comment, + sym_documentation_comment, + [137043] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6104), 1, + anon_sym_GT, + STATE(2864), 1, + aux_sym_type_arguments_repeat1, + STATE(2853), 2, + sym_comment, + sym_documentation_comment, + [137072] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6106), 1, + anon_sym_COMMA, + ACTIONS(6108), 1, + anon_sym_RPAREN, + STATE(2865), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2854), 2, + sym_comment, + sym_documentation_comment, + [137101] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6110), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(2855), 2, + sym_comment, + sym_documentation_comment, + [137130] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(578), 1, + anon_sym_RBRACE, + ACTIONS(6112), 1, + anon_sym_COMMA, + STATE(2866), 1, + aux_sym_list_literal_repeat1, + STATE(2856), 2, + sym_comment, + sym_documentation_comment, + [137159] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(580), 1, + anon_sym_RBRACK, + ACTIONS(6114), 1, + anon_sym_COMMA, + STATE(2867), 1, + aux_sym_list_literal_repeat1, + STATE(2857), 2, + sym_comment, + sym_documentation_comment, + [137188] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2858), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6116), 3, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_EQ_GT, + [137213] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(6118), 1, + anon_sym_DOT, + STATE(3549), 1, + sym_type_arguments, + STATE(2859), 2, + sym_comment, + sym_documentation_comment, + [137242] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6120), 1, + anon_sym_COMMA, + ACTIONS(6123), 1, + anon_sym_RPAREN, + STATE(2860), 3, + sym_comment, + sym_documentation_comment, + aux_sym_record_type_repeat1, + [137269] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5954), 1, + sym_identifier, + STATE(2826), 1, + sym_static_final_declaration, + STATE(3182), 1, + sym_static_final_declaration_list, + STATE(2861), 2, + sym_comment, + sym_documentation_comment, + [137298] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2567), 1, + sym_representation_declaration, + STATE(2862), 2, + sym_comment, + sym_documentation_comment, + [137327] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5368), 1, + anon_sym_LBRACE, + ACTIONS(6125), 1, + anon_sym_EQ_GT, + STATE(1265), 1, + sym_block, + STATE(2863), 2, + sym_comment, + sym_documentation_comment, + [137356] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6127), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2864), 2, + sym_comment, + sym_documentation_comment, + [137385] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3773), 1, + anon_sym_RPAREN, + ACTIONS(6129), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2865), 2, + sym_comment, + sym_documentation_comment, + [137414] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(582), 1, + anon_sym_RBRACE, + ACTIONS(6131), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2866), 2, + sym_comment, + sym_documentation_comment, + [137443] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(584), 1, + anon_sym_RBRACK, + ACTIONS(6133), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2867), 2, + sym_comment, + sym_documentation_comment, + [137472] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6135), 1, + anon_sym_COMMA, + ACTIONS(6137), 1, + anon_sym_RPAREN, + STATE(2978), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(2868), 2, + sym_comment, + sym_documentation_comment, + [137501] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(582), 1, + anon_sym_RBRACE, + ACTIONS(6131), 1, + anon_sym_COMMA, + STATE(2877), 1, + aux_sym_list_literal_repeat1, + STATE(2869), 2, + sym_comment, + sym_documentation_comment, + [137530] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(584), 1, + anon_sym_RBRACK, + ACTIONS(6133), 1, + anon_sym_COMMA, + STATE(2878), 1, + aux_sym_list_literal_repeat1, + STATE(2870), 2, + sym_comment, + sym_documentation_comment, + [137559] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6139), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2871), 2, + sym_comment, + sym_documentation_comment, + [137588] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6141), 1, + anon_sym_RPAREN, + STATE(2967), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2872), 2, + sym_comment, + sym_documentation_comment, + [137617] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6143), 1, + anon_sym_COMMA, + ACTIONS(6145), 1, + anon_sym_RPAREN, + STATE(2840), 1, + aux_sym__argument_list_repeat1, + STATE(2873), 2, + sym_comment, + sym_documentation_comment, + [137646] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6147), 1, + sym_identifier, + ACTIONS(6149), 1, + anon_sym_new, + STATE(1187), 1, + sym__new_builtin, + STATE(2874), 2, + sym_comment, + sym_documentation_comment, + [137675] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6151), 1, + anon_sym_RPAREN, + STATE(2974), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2875), 2, + sym_comment, + sym_documentation_comment, + [137704] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6153), 1, + anon_sym_RBRACE, + ACTIONS(6155), 1, + anon_sym_COMMA, + STATE(2882), 1, + aux_sym_switch_expression_repeat1, + STATE(2876), 2, + sym_comment, + sym_documentation_comment, + [137733] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(586), 1, + anon_sym_RBRACE, + ACTIONS(6157), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2877), 2, + sym_comment, + sym_documentation_comment, + [137762] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(588), 1, + anon_sym_RBRACK, + ACTIONS(6159), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2878), 2, + sym_comment, + sym_documentation_comment, + [137791] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(586), 1, + anon_sym_RBRACE, + ACTIONS(6157), 1, + anon_sym_COMMA, + STATE(2885), 1, + aux_sym_list_literal_repeat1, + STATE(2879), 2, + sym_comment, + sym_documentation_comment, + [137820] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(588), 1, + anon_sym_RBRACK, + ACTIONS(6159), 1, + anon_sym_COMMA, + STATE(2886), 1, + aux_sym_list_literal_repeat1, + STATE(2880), 2, + sym_comment, + sym_documentation_comment, + [137849] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6161), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2881), 2, + sym_comment, + sym_documentation_comment, + [137878] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1037), 1, + anon_sym_RBRACE, + ACTIONS(6163), 1, + anon_sym_COMMA, + STATE(2851), 1, + aux_sym_switch_expression_repeat1, + STATE(2882), 2, + sym_comment, + sym_documentation_comment, + [137907] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6165), 1, + anon_sym_RPAREN, + STATE(2975), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2883), 2, + sym_comment, + sym_documentation_comment, + [137936] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6167), 1, + anon_sym_COMMA, + ACTIONS(6170), 1, + anon_sym_RPAREN, + STATE(2884), 3, + sym_comment, + sym_documentation_comment, + aux_sym__for_loop_parts_repeat2, + [137963] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(590), 1, + anon_sym_RBRACE, + ACTIONS(6172), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2885), 2, + sym_comment, + sym_documentation_comment, + [137992] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(592), 1, + anon_sym_RBRACK, + ACTIONS(6174), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2886), 2, + sym_comment, + sym_documentation_comment, + [138021] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6176), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2887), 2, + sym_comment, + sym_documentation_comment, + [138050] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6178), 1, + anon_sym_RBRACE, + ACTIONS(6180), 1, + anon_sym_COMMA, + STATE(2783), 1, + aux_sym_record_type_repeat2, + STATE(2888), 2, + sym_comment, + sym_documentation_comment, + [138079] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + ACTIONS(6182), 1, + anon_sym_EQ_GT, + STATE(446), 1, + sym_block, + STATE(2889), 2, + sym_comment, + sym_documentation_comment, + [138108] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(995), 1, + anon_sym_RBRACK, + ACTIONS(6184), 1, + anon_sym_COMMA, + STATE(2945), 1, + aux_sym_list_pattern_repeat1, + STATE(2890), 2, + sym_comment, + sym_documentation_comment, + [138137] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6186), 1, + anon_sym_COMMA, + ACTIONS(6188), 1, + anon_sym_RPAREN, + STATE(2892), 1, + aux_sym_record_type_repeat1, + STATE(2891), 2, + sym_comment, + sym_documentation_comment, + [138166] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4272), 1, + anon_sym_RPAREN, + ACTIONS(6190), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2892), 2, + sym_comment, + sym_documentation_comment, + [138195] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(6192), 1, + anon_sym_LBRACE, + ACTIONS(6194), 1, + aux_sym__sub_string_test_token1, + ACTIONS(6196), 1, + sym_identifier_dollar_escaped, + STATE(2893), 2, + sym_comment, + sym_documentation_comment, + [138224] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5624), 1, + anon_sym_COLON, + ACTIONS(5466), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(2894), 2, + sym_comment, + sym_documentation_comment, + [138251] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6198), 1, + sym_identifier, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + STATE(2895), 2, + sym_comment, + sym_documentation_comment, + [138278] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6202), 1, + anon_sym_COMMA, + ACTIONS(6204), 1, + anon_sym_RPAREN, + STATE(2715), 1, + aux_sym_record_pattern_repeat1, + STATE(2896), 2, + sym_comment, + sym_documentation_comment, + [138307] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6206), 1, + anon_sym_GT, + STATE(2902), 1, + aux_sym_type_parameters_repeat1, + STATE(2897), 2, + sym_comment, + sym_documentation_comment, + [138336] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2040), 1, + sym_formal_parameter_list, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2898), 2, + sym_comment, + sym_documentation_comment, + [138365] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6208), 1, + anon_sym_COMMA, + ACTIONS(6211), 1, + anon_sym_GT, + STATE(2899), 3, + sym_comment, + sym_documentation_comment, + aux_sym_type_parameters_repeat1, + [138392] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6213), 1, + anon_sym_GT, + STATE(2914), 1, + aux_sym_type_arguments_repeat1, + STATE(2900), 2, + sym_comment, + sym_documentation_comment, + [138421] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6215), 1, + anon_sym_COMMA, + ACTIONS(6217), 1, + anon_sym_RPAREN, + STATE(2916), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2901), 2, + sym_comment, + sym_documentation_comment, + [138450] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6219), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(2902), 2, + sym_comment, + sym_documentation_comment, + [138479] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(602), 1, + anon_sym_RBRACE, + ACTIONS(6221), 1, + anon_sym_COMMA, + STATE(2917), 1, + aux_sym_list_literal_repeat1, + STATE(2903), 2, + sym_comment, + sym_documentation_comment, + [138508] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(604), 1, + anon_sym_RBRACK, + ACTIONS(6223), 1, + anon_sym_COMMA, + STATE(2918), 1, + aux_sym_list_literal_repeat1, + STATE(2904), 2, + sym_comment, + sym_documentation_comment, + [138537] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3050), 1, + sym_initialized_identifier_list, + STATE(2905), 2, + sym_comment, + sym_documentation_comment, + [138566] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3197), 1, + anon_sym_LT, + ACTIONS(5720), 1, + anon_sym_DOT, + STATE(3552), 1, + sym_type_arguments, + STATE(2906), 2, + sym_comment, + sym_documentation_comment, + [138595] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6225), 1, + sym_identifier, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + STATE(2907), 2, + sym_comment, + sym_documentation_comment, + [138622] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6228), 1, + sym_identifier, + ACTIONS(5254), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(2908), 2, + sym_comment, + sym_documentation_comment, + [138649] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(522), 1, + anon_sym_RBRACE, + ACTIONS(5956), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2909), 2, + sym_comment, + sym_documentation_comment, + [138678] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2910), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5802), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + [138703] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(6230), 1, + anon_sym_SEMI, + STATE(3046), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(2911), 2, + sym_comment, + sym_documentation_comment, + [138732] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5396), 1, + anon_sym_LBRACE, + ACTIONS(6232), 1, + anon_sym_EQ_GT, + STATE(1180), 1, + sym_block, + STATE(2912), 2, + sym_comment, + sym_documentation_comment, + [138761] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6234), 1, + anon_sym_GT, + STATE(2722), 1, + aux_sym_type_arguments_repeat1, + STATE(2913), 2, + sym_comment, + sym_documentation_comment, + [138790] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6236), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2914), 2, + sym_comment, + sym_documentation_comment, + [138819] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2915), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6238), 3, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + [138844] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3791), 1, + anon_sym_RPAREN, + ACTIONS(6240), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2916), 2, + sym_comment, + sym_documentation_comment, + [138873] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(606), 1, + anon_sym_RBRACE, + ACTIONS(6242), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2917), 2, + sym_comment, + sym_documentation_comment, + [138902] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(608), 1, + anon_sym_RBRACK, + ACTIONS(6244), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2918), 2, + sym_comment, + sym_documentation_comment, + [138931] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6246), 1, + anon_sym_COMMA, + ACTIONS(6248), 1, + anon_sym_RPAREN, + STATE(2978), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(2919), 2, + sym_comment, + sym_documentation_comment, + [138960] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(606), 1, + anon_sym_RBRACE, + ACTIONS(6242), 1, + anon_sym_COMMA, + STATE(2924), 1, + aux_sym_list_literal_repeat1, + STATE(2920), 2, + sym_comment, + sym_documentation_comment, + [138989] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(608), 1, + anon_sym_RBRACK, + ACTIONS(6244), 1, + anon_sym_COMMA, + STATE(2925), 1, + aux_sym_list_literal_repeat1, + STATE(2921), 2, + sym_comment, + sym_documentation_comment, + [139018] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5611), 1, + anon_sym_LPAREN, + ACTIONS(5613), 1, + anon_sym_DOT, + STATE(2563), 1, + sym_representation_declaration, + STATE(2922), 2, + sym_comment, + sym_documentation_comment, + [139047] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6250), 1, + anon_sym_RBRACE, + ACTIONS(6252), 1, + anon_sym_COMMA, + STATE(2928), 1, + aux_sym_switch_expression_repeat1, + STATE(2923), 2, + sym_comment, + sym_documentation_comment, + [139076] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(610), 1, + anon_sym_RBRACE, + ACTIONS(6254), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2924), 2, + sym_comment, + sym_documentation_comment, + [139105] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(612), 1, + anon_sym_RBRACK, + ACTIONS(6256), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2925), 2, + sym_comment, + sym_documentation_comment, + [139134] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(610), 1, + anon_sym_RBRACE, + ACTIONS(6254), 1, + anon_sym_COMMA, + STATE(2929), 1, + aux_sym_list_literal_repeat1, + STATE(2926), 2, + sym_comment, + sym_documentation_comment, + [139163] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(612), 1, + anon_sym_RBRACK, + ACTIONS(6256), 1, + anon_sym_COMMA, + STATE(2930), 1, + aux_sym_list_literal_repeat1, + STATE(2927), 2, + sym_comment, + sym_documentation_comment, + [139192] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1035), 1, + anon_sym_RBRACE, + ACTIONS(6258), 1, + anon_sym_COMMA, + STATE(2851), 1, + aux_sym_switch_expression_repeat1, + STATE(2928), 2, + sym_comment, + sym_documentation_comment, + [139221] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(614), 1, + anon_sym_RBRACE, + ACTIONS(6260), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2929), 2, + sym_comment, + sym_documentation_comment, + [139250] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(616), 1, + anon_sym_RBRACK, + ACTIONS(6262), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2930), 2, + sym_comment, + sym_documentation_comment, + [139279] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(524), 1, + anon_sym_RBRACE, + ACTIONS(6264), 1, + anon_sym_COMMA, + STATE(2909), 1, + aux_sym_list_literal_repeat1, + STATE(2931), 2, + sym_comment, + sym_documentation_comment, + [139308] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6266), 1, + anon_sym_COMMA, + ACTIONS(6268), 1, + anon_sym_RPAREN, + STATE(2938), 1, + aux_sym_record_type_repeat1, + STATE(2932), 2, + sym_comment, + sym_documentation_comment, + [139337] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6270), 1, + anon_sym_RBRACE, + ACTIONS(6272), 1, + anon_sym_COMMA, + STATE(2933), 3, + sym_comment, + sym_documentation_comment, + aux_sym_map_pattern_repeat1, + [139364] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6275), 1, + anon_sym_RBRACE, + ACTIONS(6277), 1, + anon_sym_COMMA, + STATE(2745), 1, + aux_sym_list_literal_repeat1, + STATE(2934), 2, + sym_comment, + sym_documentation_comment, + [139393] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6279), 1, + anon_sym_COMMA, + ACTIONS(6281), 1, + anon_sym_RBRACK, + STATE(2747), 1, + aux_sym_list_literal_repeat1, + STATE(2935), 2, + sym_comment, + sym_documentation_comment, + [139422] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(662), 1, + anon_sym_RBRACE, + ACTIONS(6283), 1, + anon_sym_COMMA, + STATE(3001), 1, + aux_sym_map_pattern_repeat1, + STATE(2936), 2, + sym_comment, + sym_documentation_comment, + [139451] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5087), 1, + anon_sym_class, + ACTIONS(5093), 1, + anon_sym_mixin, + STATE(3306), 1, + sym_mixin, + STATE(2937), 2, + sym_comment, + sym_documentation_comment, + [139480] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4284), 1, + anon_sym_RPAREN, + ACTIONS(6285), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2938), 2, + sym_comment, + sym_documentation_comment, + [139509] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4352), 1, + anon_sym_RPAREN, + ACTIONS(6287), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2939), 2, + sym_comment, + sym_documentation_comment, + [139538] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(6289), 1, + sym_identifier, + STATE(542), 1, + sym__semicolon, + STATE(2940), 2, + sym_comment, + sym_documentation_comment, + [139567] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6291), 1, + anon_sym_GT, + STATE(2946), 1, + aux_sym_type_parameters_repeat1, + STATE(2941), 2, + sym_comment, + sym_documentation_comment, + [139596] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6293), 1, + sym_identifier, + ACTIONS(4489), 2, + anon_sym_this, + anon_sym_super, + STATE(2942), 2, + sym_comment, + sym_documentation_comment, + [139623] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6296), 1, + anon_sym_GT, + STATE(2950), 1, + aux_sym_type_arguments_repeat1, + STATE(2943), 2, + sym_comment, + sym_documentation_comment, + [139652] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6298), 1, + anon_sym_COMMA, + ACTIONS(6300), 1, + anon_sym_RPAREN, + STATE(2952), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2944), 2, + sym_comment, + sym_documentation_comment, + [139681] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6302), 1, + anon_sym_COMMA, + ACTIONS(6305), 1, + anon_sym_RBRACK, + STATE(2945), 3, + sym_comment, + sym_documentation_comment, + aux_sym_list_pattern_repeat1, + [139708] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6307), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(2946), 2, + sym_comment, + sym_documentation_comment, + [139737] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(6309), 1, + sym_identifier, + STATE(2376), 1, + sym__new_builtin, + STATE(2947), 2, + sym_comment, + sym_documentation_comment, + [139766] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2948), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(4208), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [139791] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6311), 1, + anon_sym_COMMA, + ACTIONS(6313), 1, + anon_sym_RPAREN, + STATE(2999), 1, + aux_sym_record_pattern_repeat1, + STATE(2949), 2, + sym_comment, + sym_documentation_comment, + [139820] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6315), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2950), 2, + sym_comment, + sym_documentation_comment, + [139849] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(536), 1, + anon_sym_RBRACE, + ACTIONS(6317), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2951), 2, + sym_comment, + sym_documentation_comment, + [139878] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3805), 1, + anon_sym_RPAREN, + ACTIONS(6319), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2952), 2, + sym_comment, + sym_documentation_comment, + [139907] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(536), 1, + anon_sym_RBRACK, + ACTIONS(6321), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(2953), 2, + sym_comment, + sym_documentation_comment, + [139936] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2442), 1, + anon_sym_RBRACE, + ACTIONS(6323), 1, + anon_sym_COMMA, + STATE(2786), 1, + aux_sym__named_formal_parameters_repeat1, + STATE(2954), 2, + sym_comment, + sym_documentation_comment, + [139965] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6325), 1, + anon_sym_COMMA, + ACTIONS(6327), 1, + anon_sym_RPAREN, + STATE(2957), 1, + aux_sym_record_type_repeat1, + STATE(2955), 2, + sym_comment, + sym_documentation_comment, + [139994] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3567), 1, + anon_sym_LT, + ACTIONS(6329), 1, + anon_sym_on, + STATE(3402), 1, + sym_type_parameters, + STATE(2956), 2, + sym_comment, + sym_documentation_comment, + [140023] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4296), 1, + anon_sym_RPAREN, + ACTIONS(6331), 1, + anon_sym_COMMA, + STATE(2860), 1, + aux_sym_record_type_repeat1, + STATE(2957), 2, + sym_comment, + sym_documentation_comment, + [140052] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6333), 1, + anon_sym_GT, + STATE(2962), 1, + aux_sym_type_parameters_repeat1, + STATE(2958), 2, + sym_comment, + sym_documentation_comment, + [140081] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6335), 1, + anon_sym_GT, + STATE(2963), 1, + aux_sym_type_arguments_repeat1, + STATE(2959), 2, + sym_comment, + sym_documentation_comment, + [140110] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6337), 1, + anon_sym_COMMA, + ACTIONS(6339), 1, + anon_sym_RPAREN, + STATE(2964), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2960), 2, + sym_comment, + sym_documentation_comment, + [140139] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6341), 1, + anon_sym_COMMA, + ACTIONS(6343), 1, + anon_sym_RPAREN, + STATE(2978), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(2961), 2, + sym_comment, + sym_documentation_comment, + [140168] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6345), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(2962), 2, + sym_comment, + sym_documentation_comment, + [140197] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6347), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2963), 2, + sym_comment, + sym_documentation_comment, + [140226] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3811), 1, + anon_sym_RPAREN, + ACTIONS(6349), 1, + anon_sym_COMMA, + STATE(2661), 1, + aux_sym_parameter_type_list_repeat1, + STATE(2964), 2, + sym_comment, + sym_documentation_comment, + [140255] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2600), 1, + anon_sym_RBRACK, + ACTIONS(6351), 1, + anon_sym_COMMA, + STATE(2797), 1, + aux_sym__optional_postional_formal_parameters_repeat1, + STATE(2965), 2, + sym_comment, + sym_documentation_comment, + [140284] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6353), 1, + anon_sym_RPAREN, + STATE(3002), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2966), 2, + sym_comment, + sym_documentation_comment, + [140313] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6355), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2967), 2, + sym_comment, + sym_documentation_comment, + [140342] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6357), 1, + anon_sym_GT, + STATE(2969), 1, + aux_sym_type_arguments_repeat1, + STATE(2968), 2, + sym_comment, + sym_documentation_comment, + [140371] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6359), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2969), 2, + sym_comment, + sym_documentation_comment, + [140400] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(6361), 1, + anon_sym_LBRACE, + ACTIONS(6363), 1, + aux_sym__sub_string_test_token1, + ACTIONS(6365), 1, + sym_identifier_dollar_escaped, + STATE(2970), 2, + sym_comment, + sym_documentation_comment, + [140429] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6367), 1, + anon_sym_RPAREN, + STATE(3005), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2971), 2, + sym_comment, + sym_documentation_comment, + [140458] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6369), 1, + anon_sym_GT, + STATE(2973), 1, + aux_sym_type_arguments_repeat1, + STATE(2972), 2, + sym_comment, + sym_documentation_comment, + [140487] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5847), 1, + anon_sym_COMMA, + ACTIONS(6371), 1, + anon_sym_GT, + STATE(2731), 1, + aux_sym_type_arguments_repeat1, + STATE(2973), 2, + sym_comment, + sym_documentation_comment, + [140516] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6373), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2974), 2, + sym_comment, + sym_documentation_comment, + [140545] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6375), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(2975), 2, + sym_comment, + sym_documentation_comment, + [140574] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(530), 1, + anon_sym_RBRACK, + ACTIONS(6377), 1, + anon_sym_COMMA, + STATE(2762), 1, + aux_sym_list_literal_repeat1, + STATE(2976), 2, + sym_comment, + sym_documentation_comment, + [140603] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5157), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2525), 1, + sym__native, + STATE(2977), 2, + sym_comment, + sym_documentation_comment, + [140632] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6379), 1, + anon_sym_COMMA, + ACTIONS(6382), 1, + anon_sym_RPAREN, + STATE(2978), 3, + sym_comment, + sym_documentation_comment, + aux_sym__record_literal_no_const_repeat1, + [140659] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5127), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2539), 1, + sym__native, + STATE(2979), 2, + sym_comment, + sym_documentation_comment, + [140688] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5153), 1, + anon_sym_SEMI, + ACTIONS(5347), 1, + anon_sym_native, + STATE(2499), 1, + sym__native, + STATE(2980), 2, + sym_comment, + sym_documentation_comment, + [140717] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6384), 1, + anon_sym_RBRACE, + ACTIONS(6386), 1, + anon_sym_COMMA, + STATE(2984), 1, + aux_sym_record_type_repeat2, + STATE(2981), 2, + sym_comment, + sym_documentation_comment, + [140746] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2982), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6388), 3, + anon_sym_SEMI, + anon_sym_show, + anon_sym_hide, + [140771] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6390), 1, + anon_sym_COMMA, + ACTIONS(6393), 1, + anon_sym_RPAREN, + STATE(2983), 3, + sym_comment, + sym_documentation_comment, + aux_sym_record_pattern_repeat1, + [140798] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4302), 1, + anon_sym_RBRACE, + ACTIONS(6395), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2984), 2, + sym_comment, + sym_documentation_comment, + [140827] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6397), 1, + anon_sym_COMMA, + ACTIONS(6400), 1, + anon_sym_RPAREN, + STATE(2743), 1, + aux_sym__normal_formal_parameters_repeat1, + STATE(2985), 2, + sym_comment, + sym_documentation_comment, + [140856] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4304), 1, + anon_sym_RBRACE, + ACTIONS(6402), 1, + anon_sym_COMMA, + STATE(2988), 1, + aux_sym_record_type_repeat2, + STATE(2986), 2, + sym_comment, + sym_documentation_comment, + [140885] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2805), 1, + sym_formal_parameter_list, + STATE(2987), 2, + sym_comment, + sym_documentation_comment, + [140914] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4306), 1, + anon_sym_RBRACE, + ACTIONS(6404), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2988), 2, + sym_comment, + sym_documentation_comment, + [140943] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4306), 1, + anon_sym_RBRACE, + ACTIONS(6404), 1, + anon_sym_COMMA, + STATE(2993), 1, + aux_sym_record_type_repeat2, + STATE(2989), 2, + sym_comment, + sym_documentation_comment, + [140972] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5234), 1, + anon_sym_SEMI, + ACTIONS(6029), 1, + anon_sym_COMMA, + STATE(2814), 1, + aux_sym_initializers_repeat1, + STATE(2990), 2, + sym_comment, + sym_documentation_comment, + [141001] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2815), 1, + sym_formal_parameter_list, + STATE(2991), 2, + sym_comment, + sym_documentation_comment, + [141030] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6406), 1, + anon_sym_RBRACE, + ACTIONS(6408), 1, + anon_sym_COMMA, + STATE(2766), 1, + aux_sym_switch_expression_repeat1, + STATE(2992), 2, + sym_comment, + sym_documentation_comment, + [141059] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4308), 1, + anon_sym_RBRACE, + ACTIONS(6410), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2993), 2, + sym_comment, + sym_documentation_comment, + [141088] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(159), 1, + anon_sym_new, + ACTIONS(6412), 1, + sym_identifier, + STATE(3280), 1, + sym__new_builtin, + STATE(2994), 2, + sym_comment, + sym_documentation_comment, + [141117] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6414), 1, + anon_sym_RBRACE, + ACTIONS(6416), 1, + anon_sym_COMMA, + STATE(2998), 1, + aux_sym_record_type_repeat2, + STATE(2995), 2, + sym_comment, + sym_documentation_comment, + [141146] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6418), 1, + anon_sym_COMMA, + ACTIONS(6421), 1, + anon_sym_RPAREN, + STATE(2996), 3, + sym_comment, + sym_documentation_comment, + aux_sym__normal_formal_parameters_repeat1, + [141173] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(2997), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6423), 3, + anon_sym_default, + anon_sym_case, + sym_identifier, + [141198] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4312), 1, + anon_sym_RBRACE, + ACTIONS(6425), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(2998), 2, + sym_comment, + sym_documentation_comment, + [141227] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1021), 1, + anon_sym_RPAREN, + ACTIONS(6427), 1, + anon_sym_COMMA, + STATE(2983), 1, + aux_sym_record_pattern_repeat1, + STATE(2999), 2, + sym_comment, + sym_documentation_comment, + [141256] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(3000), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6429), 3, + anon_sym_this, + anon_sym_super, + sym_identifier, + [141281] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(648), 1, + anon_sym_RBRACE, + ACTIONS(6431), 1, + anon_sym_COMMA, + STATE(2933), 1, + aux_sym_map_pattern_repeat1, + STATE(3001), 2, + sym_comment, + sym_documentation_comment, + [141310] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6433), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(3002), 2, + sym_comment, + sym_documentation_comment, + [141339] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6435), 1, + anon_sym_RPAREN, + STATE(3022), 1, + aux_sym__for_loop_parts_repeat2, + STATE(3003), 2, + sym_comment, + sym_documentation_comment, + [141368] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4314), 1, + anon_sym_RBRACE, + ACTIONS(6437), 1, + anon_sym_COMMA, + STATE(3007), 1, + aux_sym_record_type_repeat2, + STATE(3004), 2, + sym_comment, + sym_documentation_comment, + [141397] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6439), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(3005), 2, + sym_comment, + sym_documentation_comment, + [141426] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(648), 1, + anon_sym_RBRACE, + ACTIONS(6431), 1, + anon_sym_COMMA, + STATE(2710), 1, + aux_sym_map_pattern_repeat1, + STATE(3006), 2, + sym_comment, + sym_documentation_comment, + [141455] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4316), 1, + anon_sym_RBRACE, + ACTIONS(6441), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3007), 2, + sym_comment, + sym_documentation_comment, + [141484] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4316), 1, + anon_sym_RBRACE, + ACTIONS(6441), 1, + anon_sym_COMMA, + STATE(3009), 1, + aux_sym_record_type_repeat2, + STATE(3008), 2, + sym_comment, + sym_documentation_comment, + [141513] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4318), 1, + anon_sym_RBRACE, + ACTIONS(6443), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3009), 2, + sym_comment, + sym_documentation_comment, + [141542] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6445), 1, + anon_sym_COMMA, + ACTIONS(6447), 1, + anon_sym_RPAREN, + STATE(2708), 1, + aux_sym_parameter_type_list_repeat1, + STATE(3010), 2, + sym_comment, + sym_documentation_comment, + [141571] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6449), 1, + anon_sym_RBRACE, + ACTIONS(6451), 1, + anon_sym_COMMA, + STATE(3014), 1, + aux_sym_record_type_repeat2, + STATE(3011), 2, + sym_comment, + sym_documentation_comment, + [141600] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(995), 1, + anon_sym_RBRACK, + ACTIONS(6184), 1, + anon_sym_COMMA, + STATE(2711), 1, + aux_sym_list_pattern_repeat1, + STATE(3012), 2, + sym_comment, + sym_documentation_comment, + [141629] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(3013), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(6453), 3, + anon_sym_LBRACE, + anon_sym_SEMI, + anon_sym_implements, + [141654] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4322), 1, + anon_sym_RBRACE, + ACTIONS(6455), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3014), 2, + sym_comment, + sym_documentation_comment, + [141683] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4324), 1, + anon_sym_RBRACE, + ACTIONS(6457), 1, + anon_sym_COMMA, + STATE(3016), 1, + aux_sym_record_type_repeat2, + STATE(3015), 2, + sym_comment, + sym_documentation_comment, + [141712] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4326), 1, + anon_sym_RBRACE, + ACTIONS(6459), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3016), 2, + sym_comment, + sym_documentation_comment, + [141741] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4326), 1, + anon_sym_RBRACE, + ACTIONS(6459), 1, + anon_sym_COMMA, + STATE(3018), 1, + aux_sym_record_type_repeat2, + STATE(3017), 2, + sym_comment, + sym_documentation_comment, + [141770] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4328), 1, + anon_sym_RBRACE, + ACTIONS(6461), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3018), 2, + sym_comment, + sym_documentation_comment, + [141799] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6463), 1, + anon_sym_RBRACE, + ACTIONS(6465), 1, + anon_sym_COMMA, + STATE(3021), 1, + aux_sym_record_type_repeat2, + STATE(3019), 2, + sym_comment, + sym_documentation_comment, + [141828] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(2911), 1, + sym_initialized_identifier, + STATE(3570), 1, + sym_initialized_identifier_list, + STATE(3020), 2, + sym_comment, + sym_documentation_comment, + [141857] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4332), 1, + anon_sym_RBRACE, + ACTIONS(6467), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3021), 2, + sym_comment, + sym_documentation_comment, + [141886] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5626), 1, + anon_sym_COMMA, + ACTIONS(6469), 1, + anon_sym_RPAREN, + STATE(2884), 1, + aux_sym__for_loop_parts_repeat2, + STATE(3022), 2, + sym_comment, + sym_documentation_comment, + [141915] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4334), 1, + anon_sym_RBRACE, + ACTIONS(6471), 1, + anon_sym_COMMA, + STATE(3024), 1, + aux_sym_record_type_repeat2, + STATE(3023), 2, + sym_comment, + sym_documentation_comment, + [141944] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4218), 1, + anon_sym_RBRACE, + ACTIONS(6473), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3024), 2, + sym_comment, + sym_documentation_comment, + [141973] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4218), 1, + anon_sym_RBRACE, + ACTIONS(6473), 1, + anon_sym_COMMA, + STATE(3026), 1, + aux_sym_record_type_repeat2, + STATE(3025), 2, + sym_comment, + sym_documentation_comment, + [142002] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4336), 1, + anon_sym_RBRACE, + ACTIONS(6475), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3026), 2, + sym_comment, + sym_documentation_comment, + [142031] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6477), 1, + anon_sym_RBRACE, + ACTIONS(6479), 1, + anon_sym_COMMA, + STATE(3028), 1, + aux_sym_record_type_repeat2, + STATE(3027), 2, + sym_comment, + sym_documentation_comment, + [142060] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4340), 1, + anon_sym_RBRACE, + ACTIONS(6481), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3028), 2, + sym_comment, + sym_documentation_comment, + [142089] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + STATE(3029), 2, + sym_comment, + sym_documentation_comment, + ACTIONS(5764), 3, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + [142114] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(989), 1, + anon_sym_RBRACK, + ACTIONS(6483), 1, + anon_sym_COMMA, + STATE(2890), 1, + aux_sym_list_pattern_repeat1, + STATE(3030), 2, + sym_comment, + sym_documentation_comment, + [142143] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(550), 1, + anon_sym_RBRACE, + ACTIONS(6485), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(3031), 2, + sym_comment, + sym_documentation_comment, + [142172] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4342), 1, + anon_sym_RBRACE, + ACTIONS(6487), 1, + anon_sym_COMMA, + STATE(3034), 1, + aux_sym_record_type_repeat2, + STATE(3032), 2, + sym_comment, + sym_documentation_comment, + [142201] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(564), 1, + anon_sym_RBRACK, + ACTIONS(6489), 1, + anon_sym_COMMA, + STATE(2705), 1, + aux_sym_list_literal_repeat1, + STATE(3033), 2, + sym_comment, + sym_documentation_comment, + [142230] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4344), 1, + anon_sym_RBRACE, + ACTIONS(6491), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3034), 2, + sym_comment, + sym_documentation_comment, + [142259] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4344), 1, + anon_sym_RBRACE, + ACTIONS(6491), 1, + anon_sym_COMMA, + STATE(3036), 1, + aux_sym_record_type_repeat2, + STATE(3035), 2, + sym_comment, + sym_documentation_comment, + [142288] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4346), 1, + anon_sym_RBRACE, + ACTIONS(6493), 1, + anon_sym_COMMA, + STATE(2831), 1, + aux_sym_record_type_repeat2, + STATE(3036), 2, + sym_comment, + sym_documentation_comment, + [142317] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4356), 1, + anon_sym_LPAREN, + STATE(2071), 1, + sym__strict_formal_parameter_list, + STATE(2333), 1, + sym_formal_parameter_list, + STATE(3037), 2, + sym_comment, + sym_documentation_comment, + [142346] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(550), 1, + anon_sym_RBRACE, + ACTIONS(6485), 1, + anon_sym_COMMA, + STATE(2806), 1, + aux_sym_list_literal_repeat1, + STATE(3038), 2, + sym_comment, + sym_documentation_comment, + [142375] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(564), 1, + anon_sym_RBRACK, + ACTIONS(6489), 1, + anon_sym_COMMA, + STATE(2807), 1, + aux_sym_list_literal_repeat1, + STATE(3039), 2, + sym_comment, + sym_documentation_comment, + [142404] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6495), 1, + sym_identifier, + ACTIONS(4481), 2, + anon_sym_this, + anon_sym_super, + STATE(3040), 2, + sym_comment, + sym_documentation_comment, + [142431] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(6498), 1, + anon_sym_SEMI, + STATE(2712), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(3041), 2, + sym_comment, + sym_documentation_comment, + [142460] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5886), 1, + anon_sym_COMMA, + ACTIONS(6500), 1, + anon_sym_GT, + STATE(2899), 1, + aux_sym_type_parameters_repeat1, + STATE(3042), 2, + sym_comment, + sym_documentation_comment, + [142489] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + ACTIONS(6502), 1, + anon_sym_DOT, + STATE(3357), 1, + sym_arguments, + STATE(3043), 2, + sym_comment, + sym_documentation_comment, + [142518] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(6504), 1, + sym_identifier, + STATE(537), 1, + sym__semicolon, + STATE(3044), 2, + sym_comment, + sym_documentation_comment, + [142547] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5093), 1, + anon_sym_mixin, + ACTIONS(6506), 1, + anon_sym_class, + STATE(3487), 1, + sym_mixin, + STATE(3045), 2, + sym_comment, + sym_documentation_comment, + [142576] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5650), 1, + anon_sym_COMMA, + ACTIONS(6508), 1, + anon_sym_SEMI, + STATE(2714), 1, + aux_sym_initialized_identifier_list_repeat1, + STATE(3046), 2, + sym_comment, + sym_documentation_comment, + [142605] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2448), 1, + anon_sym_LBRACK, + STATE(1136), 1, + sym_index_selector, + STATE(3047), 2, + sym_comment, + sym_documentation_comment, + [142631] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5322), 1, + anon_sym_native, + ACTIONS(6510), 1, + anon_sym_EQ, + STATE(3048), 2, + sym_comment, + sym_documentation_comment, + [142657] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1782), 1, + sym_enum_body, + STATE(3049), 2, + sym_comment, + sym_documentation_comment, + [142683] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1755), 1, + sym__semicolon, + STATE(3050), 2, + sym_comment, + sym_documentation_comment, + [142709] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4518), 1, + anon_sym_LPAREN, + ACTIONS(6512), 1, + anon_sym_EQ, + STATE(3051), 2, + sym_comment, + sym_documentation_comment, + [142735] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(3589), 1, + sym_arguments, + STATE(3052), 2, + sym_comment, + sym_documentation_comment, + [142761] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(2439), 1, + sym_arguments, + STATE(3053), 2, + sym_comment, + sym_documentation_comment, + [142787] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(512), 1, + sym__semicolon, + STATE(3054), 2, + sym_comment, + sym_documentation_comment, + [142813] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6514), 1, + anon_sym_DOT, + ACTIONS(6516), 1, + anon_sym_SEMI, + STATE(3055), 2, + sym_comment, + sym_documentation_comment, + [142839] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1785), 1, + sym_extension_body, + STATE(3056), 2, + sym_comment, + sym_documentation_comment, + [142865] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1779), 1, + sym_class_body, + STATE(3057), 2, + sym_comment, + sym_documentation_comment, + [142891] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1781), 1, + sym_class_body, + STATE(3058), 2, + sym_comment, + sym_documentation_comment, + [142917] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5766), 1, + anon_sym_LBRACE, + STATE(486), 1, + sym_block, + STATE(3059), 2, + sym_comment, + sym_documentation_comment, + [142943] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(547), 1, + sym__semicolon, + STATE(3060), 2, + sym_comment, + sym_documentation_comment, + [142969] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(956), 1, + sym_arguments, + STATE(3061), 2, + sym_comment, + sym_documentation_comment, + [142995] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1795), 1, + sym__semicolon, + STATE(3062), 2, + sym_comment, + sym_documentation_comment, + [143021] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6520), 1, + anon_sym_LBRACE, + ACTIONS(6522), 1, + anon_sym_LBRACK, + STATE(3063), 2, + sym_comment, + sym_documentation_comment, + [143047] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6524), 1, + sym_identifier, + STATE(2479), 1, + sym__type_name, + STATE(3064), 2, + sym_comment, + sym_documentation_comment, + [143073] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(551), 1, + sym__semicolon, + STATE(3065), 2, + sym_comment, + sym_documentation_comment, + [143099] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3329), 1, + sym_parenthesized_expression, + STATE(3066), 2, + sym_comment, + sym_documentation_comment, + [143125] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2048), 1, + anon_sym_LBRACK, + STATE(554), 1, + sym_index_selector, + STATE(3067), 2, + sym_comment, + sym_documentation_comment, + [143151] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5906), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3068), 2, + sym_comment, + sym_documentation_comment, + [143175] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6528), 1, + anon_sym_LBRACE, + ACTIONS(6530), 1, + anon_sym_LBRACK, + STATE(3069), 2, + sym_comment, + sym_documentation_comment, + [143201] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6532), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3070), 2, + sym_comment, + sym_documentation_comment, + [143225] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1792), 1, + sym_extension_body, + STATE(3071), 2, + sym_comment, + sym_documentation_comment, + [143251] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1769), 1, + sym_extension_body, + STATE(3072), 2, + sym_comment, + sym_documentation_comment, + [143277] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5360), 1, + anon_sym_LBRACE, + STATE(959), 1, + sym_block, + STATE(3073), 2, + sym_comment, + sym_documentation_comment, + [143303] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6534), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3074), 2, + sym_comment, + sym_documentation_comment, + [143327] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6536), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3075), 2, + sym_comment, + sym_documentation_comment, + [143351] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2724), 1, + sym_arguments, + STATE(3076), 2, + sym_comment, + sym_documentation_comment, + [143377] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(35), 1, + sym_for_loop_parts, + STATE(3077), 2, + sym_comment, + sym_documentation_comment, + [143403] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1811), 1, + sym_class_body, + STATE(3078), 2, + sym_comment, + sym_documentation_comment, + [143429] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2823), 1, + sym_arguments, + STATE(3079), 2, + sym_comment, + sym_documentation_comment, + [143455] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(449), 1, + sym__semicolon, + STATE(3080), 2, + sym_comment, + sym_documentation_comment, + [143481] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6097), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3081), 2, + sym_comment, + sym_documentation_comment, + [143505] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6540), 1, + sym_identifier, + STATE(1219), 1, + sym_scoped_identifier, + STATE(3082), 2, + sym_comment, + sym_documentation_comment, + [143531] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1767), 1, + sym_class_body, + STATE(3083), 2, + sym_comment, + sym_documentation_comment, + [143557] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + STATE(519), 1, + sym_block, + STATE(3084), 2, + sym_comment, + sym_documentation_comment, + [143583] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1756), 1, + sym_extension_body, + STATE(3085), 2, + sym_comment, + sym_documentation_comment, + [143609] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6542), 2, + anon_sym_class, + anon_sym_mixin, + STATE(3086), 2, + sym_comment, + sym_documentation_comment, + [143633] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6544), 1, + anon_sym_COMMA, + ACTIONS(6547), 1, + anon_sym_RPAREN, + STATE(3087), 2, + sym_comment, + sym_documentation_comment, + [143659] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6549), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3088), 2, + sym_comment, + sym_documentation_comment, + [143683] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(548), 1, + sym__semicolon, + STATE(3089), 2, + sym_comment, + sym_documentation_comment, + [143709] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4437), 1, + sym_increment_operator, + STATE(929), 1, + sym_postfix_operator, + STATE(3090), 2, + sym_comment, + sym_documentation_comment, + [143735] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(7), 1, + sym_for_loop_parts, + STATE(3091), 2, + sym_comment, + sym_documentation_comment, + [143761] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(925), 1, + sym_arguments, + STATE(3092), 2, + sym_comment, + sym_documentation_comment, + [143787] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1758), 1, + sym_enum_body, + STATE(3093), 2, + sym_comment, + sym_documentation_comment, + [143813] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2082), 1, + anon_sym_LBRACK, + STATE(852), 1, + sym_index_selector, + STATE(3094), 2, + sym_comment, + sym_documentation_comment, + [143839] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2825), 1, + sym_arguments, + STATE(3095), 2, + sym_comment, + sym_documentation_comment, + [143865] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6551), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(3096), 2, + sym_comment, + sym_documentation_comment, + [143889] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6553), 1, + anon_sym_new, + STATE(1058), 1, + sym__new_builtin, + STATE(3097), 2, + sym_comment, + sym_documentation_comment, + [143915] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1571), 1, + sym__semicolon, + STATE(3098), 2, + sym_comment, + sym_documentation_comment, + [143941] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5368), 1, + anon_sym_LBRACE, + STATE(1265), 1, + sym_block, + STATE(3099), 2, + sym_comment, + sym_documentation_comment, + [143967] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1738), 1, + sym_class_body, + STATE(3100), 2, + sym_comment, + sym_documentation_comment, + [143993] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(658), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3101), 2, + sym_comment, + sym_documentation_comment, + [144017] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1783), 1, + sym_extension_body, + STATE(3102), 2, + sym_comment, + sym_documentation_comment, + [144043] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(549), 1, + sym__semicolon, + STATE(3103), 2, + sym_comment, + sym_documentation_comment, + [144069] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6555), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3104), 2, + sym_comment, + sym_documentation_comment, + [144093] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6557), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3105), 2, + sym_comment, + sym_documentation_comment, + [144117] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6137), 1, + anon_sym_RPAREN, + ACTIONS(6536), 1, + anon_sym_COMMA, + STATE(3106), 2, + sym_comment, + sym_documentation_comment, + [144143] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1806), 1, + sym_class_body, + STATE(3107), 2, + sym_comment, + sym_documentation_comment, + [144169] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6559), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3108), 2, + sym_comment, + sym_documentation_comment, + [144193] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1790), 1, + sym_class_body, + STATE(3109), 2, + sym_comment, + sym_documentation_comment, + [144219] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + STATE(1287), 1, + sym_arguments, + STATE(3110), 2, + sym_comment, + sym_documentation_comment, + [144245] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5482), 1, + anon_sym_LBRACK, + STATE(655), 1, + sym_index_selector, + STATE(3111), 2, + sym_comment, + sym_documentation_comment, + [144271] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3193), 1, + anon_sym_LPAREN, + STATE(1411), 1, + sym_arguments, + STATE(3112), 2, + sym_comment, + sym_documentation_comment, + [144297] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + STATE(1237), 1, + sym_arguments, + STATE(3113), 2, + sym_comment, + sym_documentation_comment, + [144323] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(191), 1, + sym__semicolon, + STATE(3114), 2, + sym_comment, + sym_documentation_comment, + [144349] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1814), 1, + sym_class_body, + STATE(3115), 2, + sym_comment, + sym_documentation_comment, + [144375] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6561), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3116), 2, + sym_comment, + sym_documentation_comment, + [144399] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6563), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3117), 2, + sym_comment, + sym_documentation_comment, + [144423] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6565), 1, + sym_identifier, + ACTIONS(6567), 1, + anon_sym_class, + STATE(3118), 2, + sym_comment, + sym_documentation_comment, + [144449] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1980), 1, + sym__semicolon, + STATE(3119), 2, + sym_comment, + sym_documentation_comment, + [144475] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6569), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3120), 2, + sym_comment, + sym_documentation_comment, + [144499] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6571), 1, + anon_sym_LPAREN, + STATE(658), 1, + sym_arguments, + STATE(3121), 2, + sym_comment, + sym_documentation_comment, + [144525] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2314), 1, + anon_sym_LPAREN, + STATE(1276), 1, + sym_arguments, + STATE(3122), 2, + sym_comment, + sym_documentation_comment, + [144551] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6573), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3123), 2, + sym_comment, + sym_documentation_comment, + [144575] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5954), 1, + sym_identifier, + STATE(3155), 1, + sym_static_final_declaration, + STATE(3124), 2, + sym_comment, + sym_documentation_comment, + [144601] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1734), 1, + sym__semicolon, + STATE(3125), 2, + sym_comment, + sym_documentation_comment, + [144627] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6575), 1, + anon_sym_COMMA, + ACTIONS(6577), 1, + anon_sym_RPAREN, + STATE(3126), 2, + sym_comment, + sym_documentation_comment, + [144653] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6579), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3127), 2, + sym_comment, + sym_documentation_comment, + [144677] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1748), 1, + sym_class_body, + STATE(3128), 2, + sym_comment, + sym_documentation_comment, + [144703] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1966), 1, + sym__semicolon, + STATE(3129), 2, + sym_comment, + sym_documentation_comment, + [144729] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6581), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3130), 2, + sym_comment, + sym_documentation_comment, + [144753] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1749), 1, + sym_class_body, + STATE(3131), 2, + sym_comment, + sym_documentation_comment, + [144779] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + STATE(446), 1, + sym_block, + STATE(3132), 2, + sym_comment, + sym_documentation_comment, + [144805] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1745), 1, + sym_enum_body, + STATE(3133), 2, + sym_comment, + sym_documentation_comment, + [144831] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6583), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3134), 2, + sym_comment, + sym_documentation_comment, + [144855] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6585), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3135), 2, + sym_comment, + sym_documentation_comment, + [144879] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1722), 1, + sym__semicolon, + STATE(3136), 2, + sym_comment, + sym_documentation_comment, + [144905] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5712), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3137), 2, + sym_comment, + sym_documentation_comment, + [144929] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5884), 1, + sym_identifier, + STATE(3273), 1, + sym_initialized_identifier, + STATE(3138), 2, + sym_comment, + sym_documentation_comment, + [144955] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1776), 1, + sym_enum_body, + STATE(3139), 2, + sym_comment, + sym_documentation_comment, + [144981] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5733), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3140), 2, + sym_comment, + sym_documentation_comment, + [145005] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6211), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3141), 2, + sym_comment, + sym_documentation_comment, + [145029] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6587), 1, + anon_sym_RPAREN, + ACTIONS(6589), 1, + anon_sym_case, + STATE(3142), 2, + sym_comment, + sym_documentation_comment, + [145055] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6591), 1, + anon_sym_LBRACE, + ACTIONS(6593), 1, + anon_sym_LBRACK, + STATE(3143), 2, + sym_comment, + sym_documentation_comment, + [145081] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5766), 1, + anon_sym_LBRACE, + STATE(491), 1, + sym_block, + STATE(3144), 2, + sym_comment, + sym_documentation_comment, + [145107] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(153), 1, + sym_for_loop_parts, + STATE(3145), 2, + sym_comment, + sym_documentation_comment, + [145133] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6595), 1, + anon_sym_COMMA, + ACTIONS(6598), 1, + anon_sym_RPAREN, + STATE(3146), 2, + sym_comment, + sym_documentation_comment, + [145159] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6600), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3147), 2, + sym_comment, + sym_documentation_comment, + [145183] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1688), 1, + sym__semicolon, + STATE(3148), 2, + sym_comment, + sym_documentation_comment, + [145209] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5874), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3149), 2, + sym_comment, + sym_documentation_comment, + [145233] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5766), 1, + anon_sym_LBRACE, + STATE(489), 1, + sym_block, + STATE(3150), 2, + sym_comment, + sym_documentation_comment, + [145259] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4441), 1, + sym_increment_operator, + STATE(1392), 1, + sym_postfix_operator, + STATE(3151), 2, + sym_comment, + sym_documentation_comment, + [145285] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1737), 1, + sym_class_body, + STATE(3152), 2, + sym_comment, + sym_documentation_comment, + [145311] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1955), 1, + sym__semicolon, + STATE(3153), 2, + sym_comment, + sym_documentation_comment, + [145337] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2349), 1, + anon_sym_LBRACK, + STATE(1208), 1, + sym_index_selector, + STATE(3154), 2, + sym_comment, + sym_documentation_comment, + [145363] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5843), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(3155), 2, + sym_comment, + sym_documentation_comment, + [145387] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5396), 1, + anon_sym_LBRACE, + STATE(1180), 1, + sym_block, + STATE(3156), 2, + sym_comment, + sym_documentation_comment, + [145413] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1754), 1, + sym_class_body, + STATE(3157), 2, + sym_comment, + sym_documentation_comment, + [145439] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6602), 1, + anon_sym_COMMA, + ACTIONS(6605), 1, + anon_sym_RPAREN, + STATE(3158), 2, + sym_comment, + sym_documentation_comment, + [145465] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5376), 1, + anon_sym_native, + ACTIONS(6607), 1, + anon_sym_EQ, + STATE(3159), 2, + sym_comment, + sym_documentation_comment, + [145491] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5165), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3160), 2, + sym_comment, + sym_documentation_comment, + [145515] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6609), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3161), 2, + sym_comment, + sym_documentation_comment, + [145539] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6248), 1, + anon_sym_RPAREN, + ACTIONS(6536), 1, + anon_sym_COMMA, + STATE(3162), 2, + sym_comment, + sym_documentation_comment, + [145565] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6611), 2, + anon_sym_class, + sym_identifier, + STATE(3163), 2, + sym_comment, + sym_documentation_comment, + [145589] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5180), 1, + anon_sym_as, + STATE(3501), 1, + sym__as, + STATE(3164), 2, + sym_comment, + sym_documentation_comment, + [145615] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6613), 1, + anon_sym_DOT, + ACTIONS(6615), 1, + anon_sym_SEMI, + STATE(3165), 2, + sym_comment, + sym_documentation_comment, + [145641] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6617), 1, + sym_identifier, + STATE(1799), 1, + sym_mixin_application_class, + STATE(3166), 2, + sym_comment, + sym_documentation_comment, + [145667] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5754), 1, + anon_sym_LPAREN, + STATE(2156), 1, + sym_arguments, + STATE(3167), 2, + sym_comment, + sym_documentation_comment, + [145693] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4433), 1, + sym_increment_operator, + STATE(1507), 1, + sym_postfix_operator, + STATE(3168), 2, + sym_comment, + sym_documentation_comment, + [145719] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6619), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3169), 2, + sym_comment, + sym_documentation_comment, + [145743] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(1189), 1, + sym_arguments, + STATE(3170), 2, + sym_comment, + sym_documentation_comment, + [145769] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5254), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3171), 2, + sym_comment, + sym_documentation_comment, + [145793] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(543), 1, + sym__semicolon, + STATE(3172), 2, + sym_comment, + sym_documentation_comment, + [145819] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6621), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(3173), 2, + sym_comment, + sym_documentation_comment, + [145843] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5704), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3174), 2, + sym_comment, + sym_documentation_comment, + [145867] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(1194), 1, + sym_arguments, + STATE(3175), 2, + sym_comment, + sym_documentation_comment, + [145893] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(6), 1, + sym_for_loop_parts, + STATE(3176), 2, + sym_comment, + sym_documentation_comment, + [145919] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5974), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3177), 2, + sym_comment, + sym_documentation_comment, + [145943] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6623), 1, + sym_identifier, + STATE(1797), 1, + sym_mixin_application_class, + STATE(3178), 2, + sym_comment, + sym_documentation_comment, + [145969] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6270), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3179), 2, + sym_comment, + sym_documentation_comment, + [145993] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6625), 1, + anon_sym_COMMA, + STATE(2961), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(3180), 2, + sym_comment, + sym_documentation_comment, + [146019] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6627), 1, + anon_sym_COMMA, + ACTIONS(6629), 1, + anon_sym_RPAREN, + STATE(3181), 2, + sym_comment, + sym_documentation_comment, + [146045] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1761), 1, + sym__semicolon, + STATE(3182), 2, + sym_comment, + sym_documentation_comment, + [146071] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4399), 1, + anon_sym_LBRACK, + STATE(936), 1, + sym_index_selector, + STATE(3183), 2, + sym_comment, + sym_documentation_comment, + [146097] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1788), 1, + sym_class_body, + STATE(3184), 2, + sym_comment, + sym_documentation_comment, + [146123] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6632), 1, + anon_sym_RPAREN, + ACTIONS(6634), 1, + anon_sym_case, + STATE(3185), 2, + sym_comment, + sym_documentation_comment, + [146149] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5908), 1, + anon_sym_RPAREN, + ACTIONS(6636), 1, + anon_sym_COMMA, + STATE(3186), 2, + sym_comment, + sym_documentation_comment, + [146175] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6639), 1, + anon_sym_RPAREN, + ACTIONS(6641), 1, + anon_sym_EQ_EQ, + STATE(3187), 2, + sym_comment, + sym_documentation_comment, + [146201] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6643), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(3188), 2, + sym_comment, + sym_documentation_comment, + [146225] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6645), 1, + sym_identifier, + ACTIONS(6647), 1, + sym_const_builtin, + STATE(3189), 2, + sym_comment, + sym_documentation_comment, + [146251] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1760), 1, + sym_extension_body, + STATE(3190), 2, + sym_comment, + sym_documentation_comment, + [146277] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6649), 1, + anon_sym_LPAREN, + STATE(1917), 1, + sym_configuration_uri_condition, + STATE(3191), 2, + sym_comment, + sym_documentation_comment, + [146303] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6651), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3192), 2, + sym_comment, + sym_documentation_comment, + [146327] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6653), 1, + anon_sym_new, + STATE(1215), 1, + sym__new_builtin, + STATE(3193), 2, + sym_comment, + sym_documentation_comment, + [146353] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6305), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(3194), 2, + sym_comment, + sym_documentation_comment, + [146377] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4880), 1, + anon_sym_LBRACE, + STATE(2441), 1, + sym_block, + STATE(3195), 2, + sym_comment, + sym_documentation_comment, + [146403] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6003), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(3196), 2, + sym_comment, + sym_documentation_comment, + [146427] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1798), 1, + sym_extension_body, + STATE(3197), 2, + sym_comment, + sym_documentation_comment, + [146453] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6655), 1, + anon_sym_COMMA, + ACTIONS(6657), 1, + anon_sym_RPAREN, + STATE(3198), 2, + sym_comment, + sym_documentation_comment, + [146479] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4439), 1, + sym_increment_operator, + STATE(1114), 1, + sym_postfix_operator, + STATE(3199), 2, + sym_comment, + sym_documentation_comment, + [146505] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6659), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3200), 2, + sym_comment, + sym_documentation_comment, + [146529] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4654), 1, + anon_sym_LPAREN, + ACTIONS(4656), 1, + anon_sym_DOT, + STATE(3201), 2, + sym_comment, + sym_documentation_comment, + [146555] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2312), 1, + anon_sym_LBRACK, + STATE(669), 1, + sym_index_selector, + STATE(3202), 2, + sym_comment, + sym_documentation_comment, + [146581] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2190), 1, + anon_sym_LPAREN, + STATE(1127), 1, + sym_arguments, + STATE(3203), 2, + sym_comment, + sym_documentation_comment, + [146607] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6123), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3204), 2, + sym_comment, + sym_documentation_comment, + [146631] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6661), 1, + sym_identifier, + ACTIONS(6663), 1, + sym_const_builtin, + STATE(3205), 2, + sym_comment, + sym_documentation_comment, + [146657] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6567), 1, + anon_sym_class, + ACTIONS(6665), 1, + sym_identifier, + STATE(3206), 2, + sym_comment, + sym_documentation_comment, + [146683] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(1621), 1, + sym_arguments, + STATE(3207), 2, + sym_comment, + sym_documentation_comment, + [146709] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1740), 1, + sym_class_body, + STATE(3208), 2, + sym_comment, + sym_documentation_comment, + [146735] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6667), 1, + anon_sym_new, + STATE(2290), 1, + sym__new_builtin, + STATE(3209), 2, + sym_comment, + sym_documentation_comment, + [146761] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6669), 1, + anon_sym_COMMA, + ACTIONS(6671), 1, + anon_sym_RPAREN, + STATE(3210), 2, + sym_comment, + sym_documentation_comment, + [146787] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5998), 1, + anon_sym_RPAREN, + ACTIONS(6536), 1, + anon_sym_COMMA, + STATE(3211), 2, + sym_comment, + sym_documentation_comment, + [146813] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(155), 1, + sym_for_loop_parts, + STATE(3212), 2, + sym_comment, + sym_documentation_comment, + [146839] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6673), 1, + anon_sym_LBRACE, + ACTIONS(6675), 1, + anon_sym_LBRACK, + STATE(3213), 2, + sym_comment, + sym_documentation_comment, + [146865] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2448), 1, + anon_sym_LBRACK, + STATE(1146), 1, + sym_index_selector, + STATE(3214), 2, + sym_comment, + sym_documentation_comment, + [146891] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6677), 1, + sym_identifier, + STATE(3347), 1, + sym_identifier_list, + STATE(3215), 2, + sym_comment, + sym_documentation_comment, + [146917] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2458), 1, + sym_arguments, + STATE(3216), 2, + sym_comment, + sym_documentation_comment, + [146943] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6679), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3217), 2, + sym_comment, + sym_documentation_comment, + [146967] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6681), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3218), 2, + sym_comment, + sym_documentation_comment, + [146991] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4389), 1, + anon_sym_LBRACK, + STATE(1310), 1, + sym_index_selector, + STATE(3219), 2, + sym_comment, + sym_documentation_comment, + [147017] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6382), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3220), 2, + sym_comment, + sym_documentation_comment, + [147041] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6683), 1, + anon_sym_COMMA, + ACTIONS(6685), 1, + anon_sym_RPAREN, + STATE(3221), 2, + sym_comment, + sym_documentation_comment, + [147067] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5460), 1, + anon_sym_LBRACK, + STATE(588), 1, + sym_index_selector, + STATE(3222), 2, + sym_comment, + sym_documentation_comment, + [147093] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6687), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3223), 2, + sym_comment, + sym_documentation_comment, + [147117] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6689), 1, + anon_sym_LBRACK, + STATE(2370), 1, + sym_index_selector, + STATE(3224), 2, + sym_comment, + sym_documentation_comment, + [147143] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5460), 1, + anon_sym_LBRACK, + STATE(603), 1, + sym_index_selector, + STATE(3225), 2, + sym_comment, + sym_documentation_comment, + [147169] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2231), 1, + anon_sym_LBRACK, + STATE(1044), 1, + sym_index_selector, + STATE(3226), 2, + sym_comment, + sym_documentation_comment, + [147195] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2378), 1, + sym_arguments, + STATE(3227), 2, + sym_comment, + sym_documentation_comment, + [147221] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4419), 1, + anon_sym_LBRACK, + STATE(1173), 1, + sym_index_selector, + STATE(3228), 2, + sym_comment, + sym_documentation_comment, + [147247] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4807), 2, + anon_sym_EQ, + anon_sym_in, + STATE(3229), 2, + sym_comment, + sym_documentation_comment, + [147271] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2188), 1, + anon_sym_LBRACK, + STATE(614), 1, + sym_index_selector, + STATE(3230), 2, + sym_comment, + sym_documentation_comment, + [147297] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5482), 1, + anon_sym_LBRACK, + STATE(645), 1, + sym_index_selector, + STATE(3231), 2, + sym_comment, + sym_documentation_comment, + [147323] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6691), 1, + sym_identifier, + STATE(2754), 1, + sym__identifier_list, + STATE(3232), 2, + sym_comment, + sym_documentation_comment, + [147349] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(448), 1, + sym__semicolon, + STATE(3233), 2, + sym_comment, + sym_documentation_comment, + [147375] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6393), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3234), 2, + sym_comment, + sym_documentation_comment, + [147399] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6693), 1, + anon_sym_LPAREN, + STATE(36), 1, + sym_parenthesized_expression, + STATE(3235), 2, + sym_comment, + sym_documentation_comment, + [147425] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(37), 1, + sym_for_loop_parts, + STATE(3236), 2, + sym_comment, + sym_documentation_comment, + [147451] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6695), 1, + anon_sym_LBRACE, + ACTIONS(6697), 1, + anon_sym_LBRACK, + STATE(3237), 2, + sym_comment, + sym_documentation_comment, + [147477] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4445), 1, + sym_increment_operator, + STATE(1319), 1, + sym_postfix_operator, + STATE(3238), 2, + sym_comment, + sym_documentation_comment, + [147503] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3270), 1, + sym_parenthesized_expression, + STATE(3239), 2, + sym_comment, + sym_documentation_comment, + [147529] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5835), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3240), 2, + sym_comment, + sym_documentation_comment, + [147553] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6625), 1, + anon_sym_COMMA, + STATE(2796), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(3241), 2, + sym_comment, + sym_documentation_comment, + [147579] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6699), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3242), 2, + sym_comment, + sym_documentation_comment, + [147603] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4202), 1, + anon_sym_LBRACE, + ACTIONS(4204), 1, + anon_sym_LBRACK, + STATE(3243), 2, + sym_comment, + sym_documentation_comment, + [147629] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(34), 1, + sym_for_loop_parts, + STATE(3244), 2, + sym_comment, + sym_documentation_comment, + [147655] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6701), 1, + anon_sym_DOT, + ACTIONS(6703), 1, + anon_sym_SEMI, + STATE(3245), 2, + sym_comment, + sym_documentation_comment, + [147681] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6705), 1, + anon_sym_LBRACE, + ACTIONS(6707), 1, + anon_sym_LBRACK, + STATE(3246), 2, + sym_comment, + sym_documentation_comment, + [147707] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6709), 1, + anon_sym_new, + STATE(839), 1, + sym__new_builtin, + STATE(3247), 2, + sym_comment, + sym_documentation_comment, + [147733] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6711), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(3248), 2, + sym_comment, + sym_documentation_comment, + [147757] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4654), 1, + anon_sym_LPAREN, + ACTIONS(6713), 1, + anon_sym_DOT, + STATE(3249), 2, + sym_comment, + sym_documentation_comment, + [147783] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6715), 1, + anon_sym_RPAREN, + ACTIONS(6717), 1, + anon_sym_case, + STATE(3250), 2, + sym_comment, + sym_documentation_comment, + [147809] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6719), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(3251), 2, + sym_comment, + sym_documentation_comment, + [147833] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1794), 1, + sym_class_body, + STATE(3252), 2, + sym_comment, + sym_documentation_comment, + [147859] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1800), 1, + sym_enum_body, + STATE(3253), 2, + sym_comment, + sym_documentation_comment, + [147885] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6636), 1, + anon_sym_COMMA, + ACTIONS(6721), 1, + anon_sym_RPAREN, + STATE(3254), 2, + sym_comment, + sym_documentation_comment, + [147911] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6723), 1, + anon_sym_LPAREN, + STATE(593), 1, + sym_arguments, + STATE(3255), 2, + sym_comment, + sym_documentation_comment, + [147937] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6725), 1, + anon_sym_LBRACE, + STATE(545), 1, + sym_switch_block, + STATE(3256), 2, + sym_comment, + sym_documentation_comment, + [147963] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1623), 1, + anon_sym_while, + ACTIONS(6727), 1, + anon_sym_else, + STATE(3257), 2, + sym_comment, + sym_documentation_comment, + [147989] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1546), 1, + anon_sym_while, + ACTIONS(6729), 1, + anon_sym_else, + STATE(3258), 2, + sym_comment, + sym_documentation_comment, + [148015] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(513), 1, + sym__semicolon, + STATE(3259), 2, + sym_comment, + sym_documentation_comment, + [148041] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6731), 1, + anon_sym_LPAREN, + STATE(2427), 1, + sym_assertion_arguments, + STATE(3260), 2, + sym_comment, + sym_documentation_comment, + [148067] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6421), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3261), 2, + sym_comment, + sym_documentation_comment, + [148091] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6733), 1, + sym_identifier, + STATE(1400), 1, + sym_scoped_identifier, + STATE(3262), 2, + sym_comment, + sym_documentation_comment, + [148117] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6735), 1, + anon_sym_LBRACE, + ACTIONS(6737), 1, + anon_sym_LBRACK, + STATE(3263), 2, + sym_comment, + sym_documentation_comment, + [148143] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2390), 1, + sym_arguments, + STATE(3264), 2, + sym_comment, + sym_documentation_comment, + [148169] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2050), 1, + anon_sym_LPAREN, + STATE(902), 1, + sym_arguments, + STATE(3265), 2, + sym_comment, + sym_documentation_comment, + [148195] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6625), 1, + anon_sym_COMMA, + STATE(2868), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(3266), 2, + sym_comment, + sym_documentation_comment, + [148221] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1741), 1, + sym_class_body, + STATE(3267), 2, + sym_comment, + sym_documentation_comment, + [148247] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6739), 1, + anon_sym_LBRACE, + ACTIONS(6741), 1, + anon_sym_LBRACK, + STATE(3268), 2, + sym_comment, + sym_documentation_comment, + [148273] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4407), 1, + anon_sym_LBRACE, + ACTIONS(4409), 1, + anon_sym_LBRACK, + STATE(3269), 2, + sym_comment, + sym_documentation_comment, + [148299] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(518), 1, + sym__semicolon, + STATE(3270), 2, + sym_comment, + sym_documentation_comment, + [148325] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6743), 1, + anon_sym_LBRACE, + ACTIONS(6745), 1, + anon_sym_LBRACK, + STATE(3271), 2, + sym_comment, + sym_documentation_comment, + [148351] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1757), 1, + sym__semicolon, + STATE(3272), 2, + sym_comment, + sym_documentation_comment, + [148377] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5826), 2, + anon_sym_COMMA, + anon_sym_SEMI, + STATE(3273), 2, + sym_comment, + sym_documentation_comment, + [148401] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4668), 1, + anon_sym_with, + STATE(2704), 1, + sym_mixins, + STATE(3274), 2, + sym_comment, + sym_documentation_comment, + [148427] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(541), 1, + sym__semicolon, + STATE(3275), 2, + sym_comment, + sym_documentation_comment, + [148453] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6343), 1, + anon_sym_RPAREN, + ACTIONS(6536), 1, + anon_sym_COMMA, + STATE(3276), 2, + sym_comment, + sym_documentation_comment, + [148479] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5347), 1, + anon_sym_native, + STATE(3570), 1, + sym__native, + STATE(3277), 2, + sym_comment, + sym_documentation_comment, + [148505] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6518), 1, + anon_sym_LBRACE, + STATE(1780), 1, + sym_extension_body, + STATE(3278), 2, + sym_comment, + sym_documentation_comment, + [148531] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4518), 1, + anon_sym_LPAREN, + ACTIONS(6747), 1, + anon_sym_EQ, + STATE(3279), 2, + sym_comment, + sym_documentation_comment, + [148557] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2439), 1, + sym_arguments, + STATE(3280), 2, + sym_comment, + sym_documentation_comment, + [148583] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1768), 1, + sym_class_body, + STATE(3281), 2, + sym_comment, + sym_documentation_comment, + [148609] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6625), 1, + anon_sym_COMMA, + STATE(2919), 1, + aux_sym__record_literal_no_const_repeat1, + STATE(3282), 2, + sym_comment, + sym_documentation_comment, + [148635] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4413), 1, + anon_sym_LBRACE, + ACTIONS(4415), 1, + anon_sym_LBRACK, + STATE(3283), 2, + sym_comment, + sym_documentation_comment, + [148661] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6749), 1, + anon_sym_LBRACE, + ACTIONS(6751), 1, + anon_sym_LBRACK, + STATE(3284), 2, + sym_comment, + sym_documentation_comment, + [148687] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1971), 1, + sym__semicolon, + STATE(3285), 2, + sym_comment, + sym_documentation_comment, + [148713] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1743), 1, + sym__semicolon, + STATE(3286), 2, + sym_comment, + sym_documentation_comment, + [148739] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4906), 1, + anon_sym_LBRACE, + STATE(1796), 1, + sym_enum_body, + STATE(3287), 2, + sym_comment, + sym_documentation_comment, + [148765] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4383), 1, + anon_sym_LBRACE, + ACTIONS(4385), 1, + anon_sym_LBRACK, + STATE(3288), 2, + sym_comment, + sym_documentation_comment, + [148791] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6753), 1, + anon_sym_EQ, + ACTIONS(6755), 1, + anon_sym_in, + STATE(3289), 2, + sym_comment, + sym_documentation_comment, + [148817] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6757), 2, + anon_sym_COLON, + anon_sym_SEMI, + STATE(3290), 2, + sym_comment, + sym_documentation_comment, + [148841] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(193), 1, + sym__semicolon, + STATE(3291), 2, + sym_comment, + sym_documentation_comment, + [148867] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6759), 2, + anon_sym_LBRACE, + anon_sym_SEMI, + STATE(3292), 2, + sym_comment, + sym_documentation_comment, + [148891] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5880), 1, + sym_identifier, + STATE(3098), 1, + sym_dotted_identifier_list, + STATE(3293), 2, + sym_comment, + sym_documentation_comment, + [148917] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1778), 1, + sym_class_body, + STATE(3294), 2, + sym_comment, + sym_documentation_comment, + [148943] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6761), 1, + anon_sym_operator, + STATE(1562), 1, + sym__operator, + STATE(3295), 2, + sym_comment, + sym_documentation_comment, + [148969] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5780), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3296), 2, + sym_comment, + sym_documentation_comment, + [148993] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6763), 1, + sym_identifier, + ACTIONS(6765), 1, + anon_sym_class, + STATE(3297), 2, + sym_comment, + sym_documentation_comment, + [149019] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5880), 1, + sym_identifier, + STATE(3311), 1, + sym_dotted_identifier_list, + STATE(3298), 2, + sym_comment, + sym_documentation_comment, + [149045] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6524), 1, + sym_identifier, + STATE(2517), 1, + sym__type_name, + STATE(3299), 2, + sym_comment, + sym_documentation_comment, + [149071] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6767), 1, + anon_sym_RPAREN, + ACTIONS(6769), 1, + anon_sym_case, + STATE(3300), 2, + sym_comment, + sym_documentation_comment, + [149097] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1810), 1, + sym_class_body, + STATE(3301), 2, + sym_comment, + sym_documentation_comment, + [149123] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6771), 2, + anon_sym_COMMA, + anon_sym_RBRACK, + STATE(3302), 2, + sym_comment, + sym_documentation_comment, + [149147] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3463), 1, + anon_sym_LPAREN, + STATE(2915), 1, + sym_arguments, + STATE(3303), 2, + sym_comment, + sym_documentation_comment, + [149173] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6538), 1, + anon_sym_LPAREN, + STATE(46), 1, + sym_for_loop_parts, + STATE(3304), 2, + sym_comment, + sym_documentation_comment, + [149199] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6773), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3305), 2, + sym_comment, + sym_documentation_comment, + [149223] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6565), 1, + sym_identifier, + ACTIONS(6765), 1, + anon_sym_class, + STATE(3306), 2, + sym_comment, + sym_documentation_comment, + [149249] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5528), 2, + anon_sym_COMMA, + anon_sym_GT, + STATE(3307), 2, + sym_comment, + sym_documentation_comment, + [149273] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6775), 1, + anon_sym_get, + STATE(3373), 1, + sym__get, + STATE(3308), 2, + sym_comment, + sym_documentation_comment, + [149299] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6777), 1, + anon_sym_LPAREN, + STATE(3576), 1, + sym_catch_parameters, + STATE(3309), 2, + sym_comment, + sym_documentation_comment, + [149325] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3256), 1, + sym_parenthesized_expression, + STATE(3310), 2, + sym_comment, + sym_documentation_comment, + [149351] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1585), 1, + sym__semicolon, + STATE(3311), 2, + sym_comment, + sym_documentation_comment, + [149377] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6779), 2, + anon_sym_LBRACE, + anon_sym_implements, + STATE(3312), 2, + sym_comment, + sym_documentation_comment, + [149401] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(478), 1, + anon_sym_SEMI, + STATE(1753), 1, + sym__semicolon, + STATE(3313), 2, + sym_comment, + sym_documentation_comment, + [149427] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4662), 1, + anon_sym_LBRACE, + STATE(1775), 1, + sym_class_body, + STATE(3314), 2, + sym_comment, + sym_documentation_comment, + [149453] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6693), 1, + anon_sym_LPAREN, + STATE(32), 1, + sym_parenthesized_expression, + STATE(3315), 2, + sym_comment, + sym_documentation_comment, + [149479] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6781), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3316), 2, + sym_comment, + sym_documentation_comment, + [149503] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5182), 1, + anon_sym_SEMI, + STATE(1728), 1, + sym__semicolon, + STATE(3317), 2, + sym_comment, + sym_documentation_comment, + [149529] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(2450), 1, + anon_sym_LPAREN, + STATE(1177), 1, + sym_arguments, + STATE(3318), 2, + sym_comment, + sym_documentation_comment, + [149555] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6783), 2, + anon_sym_COLON, + anon_sym_SEMI, + STATE(3319), 2, + sym_comment, + sym_documentation_comment, + [149579] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6627), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + STATE(3320), 2, + sym_comment, + sym_documentation_comment, + [149603] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3611), 1, + sym_parenthesized_expression, + STATE(3321), 2, + sym_comment, + sym_documentation_comment, + [149629] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3618), 1, + sym_parenthesized_expression, + STATE(3322), 2, + sym_comment, + sym_documentation_comment, + [149655] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6526), 1, + anon_sym_LPAREN, + STATE(3622), 1, + sym_parenthesized_expression, + STATE(3323), 2, + sym_comment, + sym_documentation_comment, + [149681] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6060), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + STATE(3324), 2, + sym_comment, + sym_documentation_comment, + [149705] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6512), 1, + anon_sym_EQ, + STATE(3325), 2, + sym_comment, + sym_documentation_comment, + [149728] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6785), 1, + sym_identifier, + STATE(3326), 2, + sym_comment, + sym_documentation_comment, + [149751] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6787), 1, + sym_identifier, + STATE(3327), 2, + sym_comment, + sym_documentation_comment, + [149774] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6789), 1, + sym_identifier, + STATE(3328), 2, + sym_comment, + sym_documentation_comment, + [149797] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6791), 1, + anon_sym_LBRACE, + STATE(3329), 2, + sym_comment, + sym_documentation_comment, + [149820] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6793), 1, + sym_identifier, + STATE(3330), 2, + sym_comment, + sym_documentation_comment, + [149843] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4264), 1, + anon_sym_RPAREN, + STATE(3331), 2, + sym_comment, + sym_documentation_comment, + [149866] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(6795), 1, + aux_sym_documentation_comment_token1, + STATE(3332), 2, + sym_comment, + sym_documentation_comment, + [149889] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6797), 1, + anon_sym_DOT, + STATE(3333), 2, + sym_comment, + sym_documentation_comment, + [149912] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6799), 1, + sym_identifier, + STATE(3334), 2, + sym_comment, + sym_documentation_comment, + [149935] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6801), 1, + anon_sym_RPAREN, + STATE(3335), 2, + sym_comment, + sym_documentation_comment, + [149958] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6803), 1, + anon_sym_RPAREN, + STATE(3336), 2, + sym_comment, + sym_documentation_comment, + [149981] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6805), 1, + sym_identifier, + STATE(3337), 2, + sym_comment, + sym_documentation_comment, + [150004] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6807), 1, + anon_sym_RPAREN, + STATE(3338), 2, + sym_comment, + sym_documentation_comment, + [150027] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6809), 1, + anon_sym_RPAREN, + STATE(3339), 2, + sym_comment, + sym_documentation_comment, + [150050] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6811), 1, + anon_sym_RPAREN, + STATE(3340), 2, + sym_comment, + sym_documentation_comment, + [150073] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6753), 1, + anon_sym_EQ, + STATE(3341), 2, + sym_comment, + sym_documentation_comment, + [150096] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6813), 1, + anon_sym_RPAREN, + STATE(3342), 2, + sym_comment, + sym_documentation_comment, + [150119] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6815), 1, + sym_identifier, + STATE(3343), 2, + sym_comment, + sym_documentation_comment, + [150142] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6817), 1, + sym_identifier, + STATE(3344), 2, + sym_comment, + sym_documentation_comment, + [150165] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6820), 1, + sym_identifier, + STATE(3345), 2, + sym_comment, + sym_documentation_comment, + [150188] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6822), 1, + anon_sym_SEMI, + STATE(3346), 2, + sym_comment, + sym_documentation_comment, + [150211] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6824), 1, + anon_sym_SEMI, + STATE(3347), 2, + sym_comment, + sym_documentation_comment, + [150234] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6826), 1, + anon_sym_EQ, + STATE(3348), 2, + sym_comment, + sym_documentation_comment, + [150257] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6828), 1, + sym_identifier, + STATE(3349), 2, + sym_comment, + sym_documentation_comment, + [150280] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6830), 1, + sym_identifier, + STATE(3350), 2, + sym_comment, + sym_documentation_comment, + [150303] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6832), 1, + sym_identifier, + STATE(3351), 2, + sym_comment, + sym_documentation_comment, + [150326] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6834), 1, + anon_sym_DOT, + STATE(3352), 2, + sym_comment, + sym_documentation_comment, + [150349] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6300), 1, + anon_sym_RPAREN, + STATE(3353), 2, + sym_comment, + sym_documentation_comment, + [150372] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4288), 1, + anon_sym_RPAREN, + STATE(3354), 2, + sym_comment, + sym_documentation_comment, + [150395] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6836), 1, + sym_identifier, + STATE(3355), 2, + sym_comment, + sym_documentation_comment, + [150418] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6838), 1, + anon_sym_RPAREN, + STATE(3356), 2, + sym_comment, + sym_documentation_comment, + [150441] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6840), 1, + anon_sym_SEMI, + STATE(3357), 2, + sym_comment, + sym_documentation_comment, + [150464] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6842), 1, + anon_sym_RPAREN, + STATE(3358), 2, + sym_comment, + sym_documentation_comment, + [150487] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6844), 1, + anon_sym_DOT, + STATE(3359), 2, + sym_comment, + sym_documentation_comment, + [150510] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6846), 1, + ts_builtin_sym_end, + STATE(3360), 2, + sym_comment, + sym_documentation_comment, + [150533] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6848), 1, + anon_sym_RPAREN, + STATE(3361), 2, + sym_comment, + sym_documentation_comment, + [150556] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6850), 1, + sym_identifier, + STATE(3362), 2, + sym_comment, + sym_documentation_comment, + [150579] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6852), 1, + anon_sym_RPAREN, + STATE(3363), 2, + sym_comment, + sym_documentation_comment, + [150602] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6854), 1, + anon_sym_RPAREN, + STATE(3364), 2, + sym_comment, + sym_documentation_comment, + [150625] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6856), 1, + sym_identifier, + STATE(3365), 2, + sym_comment, + sym_documentation_comment, + [150648] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6858), 1, + sym_identifier, + STATE(3366), 2, + sym_comment, + sym_documentation_comment, + [150671] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6860), 1, + anon_sym_RBRACE, + STATE(3367), 2, + sym_comment, + sym_documentation_comment, + [150694] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6721), 1, + anon_sym_RPAREN, + STATE(3368), 2, + sym_comment, + sym_documentation_comment, + [150717] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6862), 1, + anon_sym_SEMI, + STATE(3369), 2, + sym_comment, + sym_documentation_comment, + [150740] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6864), 1, + anon_sym_RPAREN, + STATE(3370), 2, + sym_comment, + sym_documentation_comment, + [150763] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6866), 1, + anon_sym_RPAREN, + STATE(3371), 2, + sym_comment, + sym_documentation_comment, + [150786] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6868), 1, + sym_identifier, + STATE(3372), 2, + sym_comment, + sym_documentation_comment, + [150809] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5420), 1, + sym_identifier, + STATE(3373), 2, + sym_comment, + sym_documentation_comment, + [150832] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6870), 1, + anon_sym_COLON, + STATE(3374), 2, + sym_comment, + sym_documentation_comment, + [150855] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6872), 1, + anon_sym_COLON, + STATE(3375), 2, + sym_comment, + sym_documentation_comment, + [150878] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6874), 1, + anon_sym_RBRACK, + STATE(3376), 2, + sym_comment, + sym_documentation_comment, + [150901] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3807), 1, + anon_sym_RPAREN, + STATE(3377), 2, + sym_comment, + sym_documentation_comment, + [150924] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6876), 1, + anon_sym_RPAREN, + STATE(3378), 2, + sym_comment, + sym_documentation_comment, + [150947] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6878), 1, + anon_sym_RPAREN, + STATE(3379), 2, + sym_comment, + sym_documentation_comment, + [150970] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6880), 1, + anon_sym_SEMI, + STATE(3380), 2, + sym_comment, + sym_documentation_comment, + [150993] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6882), 1, + anon_sym_RPAREN, + STATE(3381), 2, + sym_comment, + sym_documentation_comment, + [151016] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6884), 1, + anon_sym_RPAREN, + STATE(3382), 2, + sym_comment, + sym_documentation_comment, + [151039] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6886), 1, + anon_sym_RPAREN, + STATE(3383), 2, + sym_comment, + sym_documentation_comment, + [151062] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6888), 1, + anon_sym_RPAREN, + STATE(3384), 2, + sym_comment, + sym_documentation_comment, + [151085] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6890), 1, + anon_sym_RPAREN, + STATE(3385), 2, + sym_comment, + sym_documentation_comment, + [151108] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6892), 1, + anon_sym_RPAREN, + STATE(3386), 2, + sym_comment, + sym_documentation_comment, + [151131] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6894), 1, + sym_identifier, + STATE(3387), 2, + sym_comment, + sym_documentation_comment, + [151154] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5998), 1, + anon_sym_RPAREN, + STATE(3388), 2, + sym_comment, + sym_documentation_comment, + [151177] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6896), 1, + anon_sym_SEMI, + STATE(3389), 2, + sym_comment, + sym_documentation_comment, + [151200] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6898), 1, + sym_identifier, + STATE(3390), 2, + sym_comment, + sym_documentation_comment, + [151223] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6900), 1, + anon_sym_LPAREN, + STATE(3391), 2, + sym_comment, + sym_documentation_comment, + [151246] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5087), 1, + anon_sym_class, + STATE(3392), 2, + sym_comment, + sym_documentation_comment, + [151269] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6902), 1, + sym_identifier, + STATE(3393), 2, + sym_comment, + sym_documentation_comment, + [151292] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6904), 1, + sym_identifier, + STATE(3394), 2, + sym_comment, + sym_documentation_comment, + [151315] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4656), 1, + anon_sym_DOT, + STATE(3395), 2, + sym_comment, + sym_documentation_comment, + [151338] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6339), 1, + anon_sym_RPAREN, + STATE(3396), 2, + sym_comment, + sym_documentation_comment, + [151361] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4300), 1, + anon_sym_RPAREN, + STATE(3397), 2, + sym_comment, + sym_documentation_comment, + [151384] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6906), 1, + sym_identifier, + STATE(3398), 2, + sym_comment, + sym_documentation_comment, + [151407] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6908), 1, + anon_sym_RPAREN, + STATE(3399), 2, + sym_comment, + sym_documentation_comment, + [151430] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6910), 1, + anon_sym_DOT, + STATE(3400), 2, + sym_comment, + sym_documentation_comment, + [151453] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(6912), 1, + aux_sym_comment_token1, + STATE(3401), 2, + sym_comment, + sym_documentation_comment, + [151476] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6914), 1, + anon_sym_on, + STATE(3402), 2, + sym_comment, + sym_documentation_comment, + [151499] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6916), 1, + sym_identifier, + STATE(3403), 2, + sym_comment, + sym_documentation_comment, + [151522] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6918), 1, + sym_identifier, + STATE(3404), 2, + sym_comment, + sym_documentation_comment, + [151545] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6920), 1, + sym_identifier, + STATE(3405), 2, + sym_comment, + sym_documentation_comment, + [151568] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6922), 1, + anon_sym_on, + STATE(3406), 2, + sym_comment, + sym_documentation_comment, + [151591] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6602), 1, + anon_sym_COMMA, + STATE(3407), 2, + sym_comment, + sym_documentation_comment, + [151614] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6924), 1, + anon_sym_RPAREN, + STATE(3408), 2, + sym_comment, + sym_documentation_comment, + [151637] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6926), 1, + anon_sym_COLON, + STATE(3409), 2, + sym_comment, + sym_documentation_comment, + [151660] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6928), 1, + anon_sym_RPAREN, + STATE(3410), 2, + sym_comment, + sym_documentation_comment, + [151683] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6930), 1, + anon_sym_RBRACK, + STATE(3411), 2, + sym_comment, + sym_documentation_comment, + [151706] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3813), 1, + anon_sym_RPAREN, + STATE(3412), 2, + sym_comment, + sym_documentation_comment, + [151729] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6343), 1, + anon_sym_RPAREN, + STATE(3413), 2, + sym_comment, + sym_documentation_comment, + [151752] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6932), 1, + anon_sym_RPAREN, + STATE(3414), 2, + sym_comment, + sym_documentation_comment, + [151775] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6934), 1, + anon_sym_RPAREN, + STATE(3415), 2, + sym_comment, + sym_documentation_comment, + [151798] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6936), 1, + anon_sym_RPAREN, + STATE(3416), 2, + sym_comment, + sym_documentation_comment, + [151821] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6938), 1, + anon_sym_RPAREN, + STATE(3417), 2, + sym_comment, + sym_documentation_comment, + [151844] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6940), 1, + anon_sym_RPAREN, + STATE(3418), 2, + sym_comment, + sym_documentation_comment, + [151867] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5376), 1, + anon_sym_SEMI, + STATE(3419), 2, + sym_comment, + sym_documentation_comment, + [151890] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6942), 1, + sym_identifier, + STATE(3420), 2, + sym_comment, + sym_documentation_comment, + [151913] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6944), 1, + anon_sym_on, + STATE(3421), 2, + sym_comment, + sym_documentation_comment, + [151936] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5762), 1, + sym_identifier, + STATE(3422), 2, + sym_comment, + sym_documentation_comment, + [151959] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6946), 1, + anon_sym_RPAREN, + STATE(3423), 2, + sym_comment, + sym_documentation_comment, + [151982] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6948), 1, + anon_sym_LBRACK, + STATE(3424), 2, + sym_comment, + sym_documentation_comment, + [152005] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6950), 1, + anon_sym_on, + STATE(3425), 2, + sym_comment, + sym_documentation_comment, + [152028] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6952), 1, + sym_identifier, + STATE(3426), 2, + sym_comment, + sym_documentation_comment, + [152051] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6954), 1, + sym_identifier, + STATE(3427), 2, + sym_comment, + sym_documentation_comment, + [152074] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6956), 1, + anon_sym_COLON, + STATE(3428), 2, + sym_comment, + sym_documentation_comment, + [152097] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1468), 1, + anon_sym_COLON, + STATE(3429), 2, + sym_comment, + sym_documentation_comment, + [152120] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6958), 1, + anon_sym_RBRACK, + STATE(3430), 2, + sym_comment, + sym_documentation_comment, + [152143] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6747), 1, + anon_sym_EQ, + STATE(3431), 2, + sym_comment, + sym_documentation_comment, + [152166] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6960), 1, + anon_sym_SEMI, + STATE(3432), 2, + sym_comment, + sym_documentation_comment, + [152189] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6962), 1, + anon_sym_RBRACE, + STATE(3433), 2, + sym_comment, + sym_documentation_comment, + [152212] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6964), 1, + anon_sym_RPAREN, + STATE(3434), 2, + sym_comment, + sym_documentation_comment, + [152235] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6966), 1, + sym_identifier, + STATE(3435), 2, + sym_comment, + sym_documentation_comment, + [152258] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6968), 1, + sym_identifier, + STATE(3436), 2, + sym_comment, + sym_documentation_comment, + [152281] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6970), 1, + sym_identifier, + STATE(3437), 2, + sym_comment, + sym_documentation_comment, + [152304] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6972), 1, + sym_identifier, + STATE(3438), 2, + sym_comment, + sym_documentation_comment, + [152327] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6974), 1, + sym_identifier, + STATE(3439), 2, + sym_comment, + sym_documentation_comment, + [152350] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6976), 1, + anon_sym_RBRACK, + STATE(3440), 2, + sym_comment, + sym_documentation_comment, + [152373] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6978), 1, + anon_sym_RBRACK, + STATE(3441), 2, + sym_comment, + sym_documentation_comment, + [152396] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6980), 1, + anon_sym_RPAREN, + STATE(3442), 2, + sym_comment, + sym_documentation_comment, + [152419] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6982), 1, + anon_sym_RPAREN, + STATE(3443), 2, + sym_comment, + sym_documentation_comment, + [152442] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6984), 1, + sym_identifier, + STATE(3444), 2, + sym_comment, + sym_documentation_comment, + [152465] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6986), 1, + sym_identifier, + STATE(3445), 2, + sym_comment, + sym_documentation_comment, + [152488] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6988), 1, + sym_identifier, + STATE(3446), 2, + sym_comment, + sym_documentation_comment, + [152511] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6990), 1, + anon_sym_RBRACK, + STATE(3447), 2, + sym_comment, + sym_documentation_comment, + [152534] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6671), 1, + anon_sym_RPAREN, + STATE(3448), 2, + sym_comment, + sym_documentation_comment, + [152557] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6992), 1, + anon_sym_EQ, + STATE(3449), 2, + sym_comment, + sym_documentation_comment, + [152580] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6994), 1, + sym_identifier, + STATE(3450), 2, + sym_comment, + sym_documentation_comment, + [152603] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6996), 1, + sym_identifier, + STATE(3451), 2, + sym_comment, + sym_documentation_comment, + [152626] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6998), 1, + anon_sym_RBRACK, + STATE(3452), 2, + sym_comment, + sym_documentation_comment, + [152649] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7000), 1, + anon_sym_class, + STATE(3453), 2, + sym_comment, + sym_documentation_comment, + [152672] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7002), 1, + sym_identifier, + STATE(3454), 2, + sym_comment, + sym_documentation_comment, + [152695] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7004), 1, + sym_identifier, + STATE(3455), 2, + sym_comment, + sym_documentation_comment, + [152718] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7006), 1, + sym_identifier, + STATE(3456), 2, + sym_comment, + sym_documentation_comment, + [152741] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7008), 1, + anon_sym_RBRACK, + STATE(3457), 2, + sym_comment, + sym_documentation_comment, + [152764] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4232), 1, + anon_sym_RPAREN, + STATE(3458), 2, + sym_comment, + sym_documentation_comment, + [152787] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7010), 1, + sym_identifier, + STATE(3459), 2, + sym_comment, + sym_documentation_comment, + [152810] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7012), 1, + sym_identifier, + STATE(3460), 2, + sym_comment, + sym_documentation_comment, + [152833] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7014), 1, + sym_identifier, + STATE(3461), 2, + sym_comment, + sym_documentation_comment, + [152856] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7016), 1, + anon_sym_RBRACK, + STATE(3462), 2, + sym_comment, + sym_documentation_comment, + [152879] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7018), 1, + anon_sym_COLON, + STATE(3463), 2, + sym_comment, + sym_documentation_comment, + [152902] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7020), 1, + sym_identifier, + STATE(3464), 2, + sym_comment, + sym_documentation_comment, + [152925] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7022), 1, + sym_identifier, + STATE(3465), 2, + sym_comment, + sym_documentation_comment, + [152948] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7024), 1, + anon_sym_RBRACK, + STATE(3466), 2, + sym_comment, + sym_documentation_comment, + [152971] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7026), 1, + sym_identifier, + STATE(3467), 2, + sym_comment, + sym_documentation_comment, + [152994] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3787), 1, + anon_sym_RPAREN, + STATE(3468), 2, + sym_comment, + sym_documentation_comment, + [153017] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7028), 1, + anon_sym_SEMI, + STATE(3469), 2, + sym_comment, + sym_documentation_comment, + [153040] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7030), 1, + sym_identifier, + STATE(3470), 2, + sym_comment, + sym_documentation_comment, + [153063] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7032), 1, + anon_sym_RPAREN, + STATE(3471), 2, + sym_comment, + sym_documentation_comment, + [153086] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7034), 1, + anon_sym_EQ, + STATE(3472), 2, + sym_comment, + sym_documentation_comment, + [153109] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7036), 1, + sym_identifier, + STATE(3473), 2, + sym_comment, + sym_documentation_comment, + [153132] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7038), 1, + anon_sym_RPAREN, + STATE(3474), 2, + sym_comment, + sym_documentation_comment, + [153155] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7040), 1, + sym_identifier, + STATE(3475), 2, + sym_comment, + sym_documentation_comment, + [153178] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7042), 1, + anon_sym_EQ, + STATE(3476), 2, + sym_comment, + sym_documentation_comment, + [153201] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5908), 1, + anon_sym_RPAREN, + STATE(3477), 2, + sym_comment, + sym_documentation_comment, + [153224] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7044), 1, + anon_sym_RPAREN, + STATE(3478), 2, + sym_comment, + sym_documentation_comment, + [153247] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7046), 1, + anon_sym_LBRACE, + STATE(3479), 2, + sym_comment, + sym_documentation_comment, + [153270] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7048), 1, + anon_sym_COLON, + STATE(3480), 2, + sym_comment, + sym_documentation_comment, + [153293] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7050), 1, + anon_sym_RPAREN, + STATE(3481), 2, + sym_comment, + sym_documentation_comment, + [153316] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7052), 1, + sym_identifier, + STATE(3482), 2, + sym_comment, + sym_documentation_comment, + [153339] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7054), 1, + anon_sym_RPAREN, + STATE(3483), 2, + sym_comment, + sym_documentation_comment, + [153362] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7056), 1, + sym_identifier, + STATE(3484), 2, + sym_comment, + sym_documentation_comment, + [153385] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7058), 1, + anon_sym_RPAREN, + STATE(3485), 2, + sym_comment, + sym_documentation_comment, + [153408] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7060), 1, + anon_sym_RBRACK, + STATE(3486), 2, + sym_comment, + sym_documentation_comment, + [153431] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7062), 1, + anon_sym_class, + STATE(3487), 2, + sym_comment, + sym_documentation_comment, + [153454] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7064), 1, + sym_identifier, + STATE(3488), 2, + sym_comment, + sym_documentation_comment, + [153477] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6217), 1, + anon_sym_RPAREN, + STATE(3489), 2, + sym_comment, + sym_documentation_comment, + [153500] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4276), 1, + anon_sym_RPAREN, + STATE(3490), 2, + sym_comment, + sym_documentation_comment, + [153523] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7066), 1, + anon_sym_class, + STATE(3491), 2, + sym_comment, + sym_documentation_comment, + [153546] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7068), 1, + anon_sym_RPAREN, + STATE(3492), 2, + sym_comment, + sym_documentation_comment, + [153569] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6108), 1, + anon_sym_RPAREN, + STATE(3493), 2, + sym_comment, + sym_documentation_comment, + [153592] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7070), 1, + sym_identifier, + STATE(3494), 2, + sym_comment, + sym_documentation_comment, + [153615] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7072), 1, + sym_identifier, + STATE(3495), 2, + sym_comment, + sym_documentation_comment, + [153638] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7074), 1, + sym_identifier, + STATE(3496), 2, + sym_comment, + sym_documentation_comment, + [153661] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7076), 1, + anon_sym_RBRACE, + STATE(3497), 2, + sym_comment, + sym_documentation_comment, + [153684] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7078), 1, + anon_sym_COLON, + STATE(3498), 2, + sym_comment, + sym_documentation_comment, + [153707] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7080), 1, + sym_identifier, + STATE(3499), 2, + sym_comment, + sym_documentation_comment, + [153730] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7082), 1, + sym_identifier, + STATE(3500), 2, + sym_comment, + sym_documentation_comment, + [153753] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7084), 1, + sym_identifier, + STATE(3501), 2, + sym_comment, + sym_documentation_comment, + [153776] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7086), 1, + sym_identifier, + STATE(3502), 2, + sym_comment, + sym_documentation_comment, + [153799] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7088), 1, + sym_identifier, + STATE(3503), 2, + sym_comment, + sym_documentation_comment, + [153822] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6703), 1, + anon_sym_SEMI, + STATE(3504), 2, + sym_comment, + sym_documentation_comment, + [153845] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5962), 1, + anon_sym_RPAREN, + STATE(3505), 2, + sym_comment, + sym_documentation_comment, + [153868] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3801), 1, + anon_sym_RPAREN, + STATE(3506), 2, + sym_comment, + sym_documentation_comment, + [153891] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7090), 1, + sym_identifier, + STATE(3507), 2, + sym_comment, + sym_documentation_comment, + [153914] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7092), 1, + anon_sym_COLON, + STATE(3508), 2, + sym_comment, + sym_documentation_comment, + [153937] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7094), 1, + sym_identifier, + STATE(3509), 2, + sym_comment, + sym_documentation_comment, + [153960] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5322), 1, + anon_sym_SEMI, + STATE(3510), 2, + sym_comment, + sym_documentation_comment, + [153983] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7096), 1, + anon_sym_EQ_GT, + STATE(3511), 2, + sym_comment, + sym_documentation_comment, + [154006] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7098), 1, + anon_sym_RPAREN, + STATE(3512), 2, + sym_comment, + sym_documentation_comment, + [154029] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7100), 1, + anon_sym_RPAREN, + STATE(3513), 2, + sym_comment, + sym_documentation_comment, + [154052] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7102), 1, + anon_sym_RPAREN, + STATE(3514), 2, + sym_comment, + sym_documentation_comment, + [154075] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7104), 1, + anon_sym_RPAREN, + STATE(3515), 2, + sym_comment, + sym_documentation_comment, + [154098] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7106), 1, + anon_sym_DOT, + STATE(3516), 2, + sym_comment, + sym_documentation_comment, + [154121] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4250), 1, + anon_sym_RPAREN, + STATE(3517), 2, + sym_comment, + sym_documentation_comment, + [154144] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5339), 1, + anon_sym_EQ, + STATE(3518), 2, + sym_comment, + sym_documentation_comment, + [154167] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7108), 1, + anon_sym_RPAREN, + STATE(3519), 2, + sym_comment, + sym_documentation_comment, + [154190] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(4750), 1, + anon_sym_RBRACE, + STATE(3520), 2, + sym_comment, + sym_documentation_comment, + [154213] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7110), 1, + anon_sym_RBRACE, + STATE(3521), 2, + sym_comment, + sym_documentation_comment, + [154236] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7112), 1, + sym_identifier, + STATE(3522), 2, + sym_comment, + sym_documentation_comment, + [154259] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6605), 1, + anon_sym_RPAREN, + STATE(3523), 2, + sym_comment, + sym_documentation_comment, + [154282] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7114), 1, + sym_identifier, + STATE(3524), 2, + sym_comment, + sym_documentation_comment, + [154305] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7116), 1, + sym_identifier, + STATE(3525), 2, + sym_comment, + sym_documentation_comment, + [154328] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7118), 1, + anon_sym_RPAREN, + STATE(3526), 2, + sym_comment, + sym_documentation_comment, + [154351] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7120), 1, + anon_sym_RPAREN, + STATE(3527), 2, + sym_comment, + sym_documentation_comment, + [154374] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7122), 1, + sym_identifier, + STATE(3528), 2, + sym_comment, + sym_documentation_comment, + [154397] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7124), 1, + anon_sym_EQ, + STATE(3529), 2, + sym_comment, + sym_documentation_comment, + [154420] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7126), 1, + anon_sym_DOT, + STATE(3530), 2, + sym_comment, + sym_documentation_comment, + [154443] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7128), 1, + sym_identifier, + STATE(3531), 2, + sym_comment, + sym_documentation_comment, + [154466] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(1578), 1, + sym_part_of_builtin, + STATE(3532), 2, + sym_comment, + sym_documentation_comment, + [154489] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7130), 1, + anon_sym_as, + STATE(3533), 2, + sym_comment, + sym_documentation_comment, + [154512] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6137), 1, + anon_sym_RPAREN, + STATE(3534), 2, + sym_comment, + sym_documentation_comment, + [154535] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7132), 1, + sym_identifier, + STATE(3535), 2, + sym_comment, + sym_documentation_comment, + [154558] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7134), 1, + anon_sym_RPAREN, + STATE(3536), 2, + sym_comment, + sym_documentation_comment, + [154581] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7136), 1, + anon_sym_DOT, + STATE(3537), 2, + sym_comment, + sym_documentation_comment, + [154604] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7138), 1, + anon_sym_RBRACE, + STATE(3538), 2, + sym_comment, + sym_documentation_comment, + [154627] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7140), 1, + anon_sym_RPAREN, + STATE(3539), 2, + sym_comment, + sym_documentation_comment, + [154650] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7142), 1, + anon_sym_LPAREN, + STATE(3540), 2, + sym_comment, + sym_documentation_comment, + [154673] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7144), 1, + anon_sym_DOT, + STATE(3541), 2, + sym_comment, + sym_documentation_comment, + [154696] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7146), 1, + anon_sym_RPAREN, + STATE(3542), 2, + sym_comment, + sym_documentation_comment, + [154719] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7148), 1, + sym_identifier, + STATE(3543), 2, + sym_comment, + sym_documentation_comment, + [154742] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5016), 1, + anon_sym_SEMI, + STATE(3544), 2, + sym_comment, + sym_documentation_comment, + [154765] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7150), 1, + sym_identifier, + STATE(3545), 2, + sym_comment, + sym_documentation_comment, + [154788] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7152), 1, + anon_sym_RPAREN, + STATE(3546), 2, + sym_comment, + sym_documentation_comment, + [154811] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7154), 1, + sym_identifier, + STATE(3547), 2, + sym_comment, + sym_documentation_comment, + [154834] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6248), 1, + anon_sym_RPAREN, + STATE(3548), 2, + sym_comment, + sym_documentation_comment, + [154857] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7156), 1, + anon_sym_DOT, + STATE(3549), 2, + sym_comment, + sym_documentation_comment, + [154880] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7158), 1, + anon_sym_EQ, + STATE(3550), 2, + sym_comment, + sym_documentation_comment, + [154903] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7160), 1, + anon_sym_SEMI, + STATE(3551), 2, + sym_comment, + sym_documentation_comment, + [154926] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6713), 1, + anon_sym_DOT, + STATE(3552), 2, + sym_comment, + sym_documentation_comment, + [154949] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7162), 1, + sym_identifier, + STATE(3553), 2, + sym_comment, + sym_documentation_comment, + [154972] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7164), 1, + anon_sym_RPAREN, + STATE(3554), 2, + sym_comment, + sym_documentation_comment, + [154995] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6447), 1, + anon_sym_RPAREN, + STATE(3555), 2, + sym_comment, + sym_documentation_comment, + [155018] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7166), 1, + anon_sym_RPAREN, + STATE(3556), 2, + sym_comment, + sym_documentation_comment, + [155041] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6595), 1, + anon_sym_COMMA, + STATE(3557), 2, + sym_comment, + sym_documentation_comment, + [155064] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6544), 1, + anon_sym_COMMA, + STATE(3558), 2, + sym_comment, + sym_documentation_comment, + [155087] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5549), 1, + anon_sym_SEMI, + STATE(3559), 2, + sym_comment, + sym_documentation_comment, + [155110] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7168), 1, + sym_identifier, + STATE(3560), 2, + sym_comment, + sym_documentation_comment, + [155133] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7170), 1, + sym_identifier, + STATE(3561), 2, + sym_comment, + sym_documentation_comment, + [155156] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7172), 1, + anon_sym_RPAREN, + STATE(3562), 2, + sym_comment, + sym_documentation_comment, + [155179] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7174), 1, + anon_sym_LBRACE, + STATE(3563), 2, + sym_comment, + sym_documentation_comment, + [155202] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7176), 1, + anon_sym_COLON, + STATE(3564), 2, + sym_comment, + sym_documentation_comment, + [155225] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7178), 1, + sym_identifier, + STATE(3565), 2, + sym_comment, + sym_documentation_comment, + [155248] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7180), 1, + anon_sym_COLON, + STATE(3566), 2, + sym_comment, + sym_documentation_comment, + [155271] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(7182), 1, + anon_sym_LF, + STATE(3567), 2, + sym_comment, + sym_documentation_comment, + [155294] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7184), 1, + anon_sym_RPAREN, + STATE(3568), 2, + sym_comment, + sym_documentation_comment, + [155317] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7186), 1, + anon_sym_RPAREN, + STATE(3569), 2, + sym_comment, + sym_documentation_comment, + [155340] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7188), 1, + anon_sym_SEMI, + STATE(3570), 2, + sym_comment, + sym_documentation_comment, + [155363] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7190), 1, + sym_identifier, + STATE(3571), 2, + sym_comment, + sym_documentation_comment, + [155386] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7192), 1, + anon_sym_SEMI, + STATE(3572), 2, + sym_comment, + sym_documentation_comment, + [155409] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7194), 1, + anon_sym_SEMI, + STATE(3573), 2, + sym_comment, + sym_documentation_comment, + [155432] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7196), 1, + anon_sym_RBRACK, + STATE(3574), 2, + sym_comment, + sym_documentation_comment, + [155455] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7198), 1, + anon_sym_COLON, + STATE(3575), 2, + sym_comment, + sym_documentation_comment, + [155478] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7200), 1, + anon_sym_LBRACE, + STATE(3576), 2, + sym_comment, + sym_documentation_comment, + [155501] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3799), 1, + anon_sym_RPAREN, + STATE(3577), 2, + sym_comment, + sym_documentation_comment, + [155524] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7202), 1, + anon_sym_RPAREN, + STATE(3578), 2, + sym_comment, + sym_documentation_comment, + [155547] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7204), 1, + anon_sym_RPAREN, + STATE(3579), 2, + sym_comment, + sym_documentation_comment, + [155570] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7206), 1, + anon_sym_RPAREN, + STATE(3580), 2, + sym_comment, + sym_documentation_comment, + [155593] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7208), 1, + sym_identifier, + STATE(3581), 2, + sym_comment, + sym_documentation_comment, + [155616] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7210), 1, + anon_sym_RPAREN, + STATE(3582), 2, + sym_comment, + sym_documentation_comment, + [155639] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7212), 1, + anon_sym_RPAREN, + STATE(3583), 2, + sym_comment, + sym_documentation_comment, + [155662] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7214), 1, + sym_identifier, + STATE(3584), 2, + sym_comment, + sym_documentation_comment, + [155685] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7216), 1, + sym_identifier, + STATE(3585), 2, + sym_comment, + sym_documentation_comment, + [155708] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7218), 1, + anon_sym_RPAREN, + STATE(3586), 2, + sym_comment, + sym_documentation_comment, + [155731] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(7220), 1, + aux_sym_script_tag_token1, + STATE(3587), 2, + sym_comment, + sym_documentation_comment, + [155754] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7222), 1, + sym_identifier, + STATE(3588), 2, + sym_comment, + sym_documentation_comment, + [155777] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7224), 1, + anon_sym_SEMI, + STATE(3589), 2, + sym_comment, + sym_documentation_comment, + [155800] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7226), 1, + anon_sym_RPAREN, + STATE(3590), 2, + sym_comment, + sym_documentation_comment, + [155823] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7228), 1, + anon_sym_RPAREN, + STATE(3591), 2, + sym_comment, + sym_documentation_comment, + [155846] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7230), 1, + anon_sym_EQ, + STATE(3592), 2, + sym_comment, + sym_documentation_comment, + [155869] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7232), 1, + anon_sym_LPAREN, + STATE(3593), 2, + sym_comment, + sym_documentation_comment, + [155892] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7234), 1, + anon_sym_RPAREN, + STATE(3594), 2, + sym_comment, + sym_documentation_comment, + [155915] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7236), 1, + anon_sym_RPAREN, + STATE(3595), 2, + sym_comment, + sym_documentation_comment, + [155938] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7238), 1, + sym_identifier, + STATE(3596), 2, + sym_comment, + sym_documentation_comment, + [155961] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7240), 1, + anon_sym_LPAREN, + STATE(3597), 2, + sym_comment, + sym_documentation_comment, + [155984] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7242), 1, + sym_identifier, + STATE(3598), 2, + sym_comment, + sym_documentation_comment, + [156007] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7244), 1, + anon_sym_LPAREN, + STATE(3599), 2, + sym_comment, + sym_documentation_comment, + [156030] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7246), 1, + anon_sym_RBRACK, + STATE(3600), 2, + sym_comment, + sym_documentation_comment, + [156053] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6636), 1, + anon_sym_COMMA, + STATE(3601), 2, + sym_comment, + sym_documentation_comment, + [156076] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7248), 1, + anon_sym_LPAREN, + STATE(3602), 2, + sym_comment, + sym_documentation_comment, + [156099] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7250), 1, + sym_identifier, + STATE(3603), 2, + sym_comment, + sym_documentation_comment, + [156122] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7252), 1, + anon_sym_while, + STATE(3604), 2, + sym_comment, + sym_documentation_comment, + [156145] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7254), 1, + sym_identifier, + STATE(3605), 2, + sym_comment, + sym_documentation_comment, + [156168] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7256), 1, + sym_identifier, + STATE(3606), 2, + sym_comment, + sym_documentation_comment, + [156191] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5295), 1, + anon_sym_SEMI, + STATE(3607), 2, + sym_comment, + sym_documentation_comment, + [156214] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7258), 1, + sym_identifier, + STATE(3608), 2, + sym_comment, + sym_documentation_comment, + [156237] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7260), 1, + anon_sym_RPAREN, + STATE(3609), 2, + sym_comment, + sym_documentation_comment, + [156260] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7262), 1, + anon_sym_RPAREN, + STATE(3610), 2, + sym_comment, + sym_documentation_comment, + [156283] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7264), 1, + anon_sym_LBRACE, + STATE(3611), 2, + sym_comment, + sym_documentation_comment, + [156306] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5430), 1, + sym_identifier, + STATE(3612), 2, + sym_comment, + sym_documentation_comment, + [156329] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7266), 1, + anon_sym_SLASH, + STATE(3613), 2, + sym_comment, + sym_documentation_comment, + [156352] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7268), 1, + anon_sym_RPAREN, + STATE(3614), 2, + sym_comment, + sym_documentation_comment, + [156375] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7270), 1, + sym_identifier, + STATE(3615), 2, + sym_comment, + sym_documentation_comment, + [156398] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7272), 1, + anon_sym_RPAREN, + STATE(3616), 2, + sym_comment, + sym_documentation_comment, + [156421] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7274), 1, + anon_sym_LPAREN, + STATE(3617), 2, + sym_comment, + sym_documentation_comment, + [156444] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7276), 1, + anon_sym_LBRACE, + STATE(3618), 2, + sym_comment, + sym_documentation_comment, + [156467] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(6506), 1, + anon_sym_class, + STATE(3619), 2, + sym_comment, + sym_documentation_comment, + [156490] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(3777), 1, + anon_sym_RPAREN, + STATE(3620), 2, + sym_comment, + sym_documentation_comment, + [156513] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7278), 1, + anon_sym_RPAREN, + STATE(3621), 2, + sym_comment, + sym_documentation_comment, + [156536] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7280), 1, + anon_sym_LBRACE, + STATE(3622), 2, + sym_comment, + sym_documentation_comment, + [156559] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7282), 1, + anon_sym_RPAREN, + STATE(3623), 2, + sym_comment, + sym_documentation_comment, + [156582] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7284), 1, + anon_sym_RPAREN, + STATE(3624), 2, + sym_comment, + sym_documentation_comment, + [156605] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7286), 1, + anon_sym_class, + STATE(3625), 2, + sym_comment, + sym_documentation_comment, + [156628] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7288), 1, + anon_sym_RPAREN, + STATE(3626), 2, + sym_comment, + sym_documentation_comment, + [156651] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7290), 1, + sym_identifier, + STATE(3627), 2, + sym_comment, + sym_documentation_comment, + [156674] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7292), 1, + anon_sym_RPAREN, + STATE(3628), 2, + sym_comment, + sym_documentation_comment, + [156697] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7294), 1, + anon_sym_LPAREN, + STATE(3629), 2, + sym_comment, + sym_documentation_comment, + [156720] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7296), 1, + anon_sym_LPAREN, + STATE(3630), 2, + sym_comment, + sym_documentation_comment, + [156743] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7298), 1, + anon_sym_SEMI, + STATE(3631), 2, + sym_comment, + sym_documentation_comment, + [156766] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7300), 1, + anon_sym_part, + STATE(3632), 2, + sym_comment, + sym_documentation_comment, + [156789] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(5200), 1, + anon_sym_SLASH_STAR, + ACTIONS(5202), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(7302), 1, + aux_sym_comment_token2, + STATE(3633), 2, + sym_comment, + sym_documentation_comment, + [156812] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_SLASH_SLASH_SLASH, + ACTIONS(9), 1, + sym__block_comment, + ACTIONS(11), 1, + sym__documentation_block_comment, + ACTIONS(7304), 1, + anon_sym_RPAREN, + STATE(3634), 2, + sym_comment, + sym_documentation_comment, + [156835] = 1, + ACTIONS(7306), 1, + ts_builtin_sym_end, + [156839] = 1, + ACTIONS(7308), 1, + ts_builtin_sym_end, + [156843] = 1, + ACTIONS(7310), 1, + ts_builtin_sym_end, + [156847] = 1, + ACTIONS(7312), 1, + ts_builtin_sym_end, + [156851] = 1, + ACTIONS(7314), 1, + ts_builtin_sym_end, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(494)] = 0, + [SMALL_STATE(495)] = 93, + [SMALL_STATE(496)] = 186, + [SMALL_STATE(497)] = 333, + [SMALL_STATE(498)] = 480, + [SMALL_STATE(499)] = 627, + [SMALL_STATE(500)] = 774, + [SMALL_STATE(501)] = 913, + [SMALL_STATE(502)] = 1060, + [SMALL_STATE(503)] = 1207, + [SMALL_STATE(504)] = 1354, + [SMALL_STATE(505)] = 1501, + [SMALL_STATE(506)] = 1648, + [SMALL_STATE(507)] = 1785, + [SMALL_STATE(508)] = 1876, + [SMALL_STATE(509)] = 1988, + [SMALL_STATE(510)] = 2096, + [SMALL_STATE(511)] = 2192, + [SMALL_STATE(512)] = 2344, + [SMALL_STATE(513)] = 2424, + [SMALL_STATE(514)] = 2504, + [SMALL_STATE(515)] = 2656, + [SMALL_STATE(516)] = 2768, + [SMALL_STATE(517)] = 2874, + [SMALL_STATE(518)] = 2984, + [SMALL_STATE(519)] = 3063, + [SMALL_STATE(520)] = 3142, + [SMALL_STATE(521)] = 3221, + [SMALL_STATE(522)] = 3300, + [SMALL_STATE(523)] = 3379, + [SMALL_STATE(524)] = 3458, + [SMALL_STATE(525)] = 3537, + [SMALL_STATE(526)] = 3626, + [SMALL_STATE(527)] = 3705, + [SMALL_STATE(528)] = 3786, + [SMALL_STATE(529)] = 3865, + [SMALL_STATE(530)] = 3944, + [SMALL_STATE(531)] = 4023, + [SMALL_STATE(532)] = 4102, + [SMALL_STATE(533)] = 4181, + [SMALL_STATE(534)] = 4360, + [SMALL_STATE(535)] = 4439, + [SMALL_STATE(536)] = 4518, + [SMALL_STATE(537)] = 4609, + [SMALL_STATE(538)] = 4688, + [SMALL_STATE(539)] = 4767, + [SMALL_STATE(540)] = 4846, + [SMALL_STATE(541)] = 4925, + [SMALL_STATE(542)] = 5004, + [SMALL_STATE(543)] = 5083, + [SMALL_STATE(544)] = 5162, + [SMALL_STATE(545)] = 5243, + [SMALL_STATE(546)] = 5322, + [SMALL_STATE(547)] = 5401, + [SMALL_STATE(548)] = 5480, + [SMALL_STATE(549)] = 5559, + [SMALL_STATE(550)] = 5638, + [SMALL_STATE(551)] = 5717, + [SMALL_STATE(552)] = 5796, + [SMALL_STATE(553)] = 5874, + [SMALL_STATE(554)] = 5952, + [SMALL_STATE(555)] = 6030, + [SMALL_STATE(556)] = 6108, + [SMALL_STATE(557)] = 6196, + [SMALL_STATE(558)] = 6286, + [SMALL_STATE(559)] = 6364, + [SMALL_STATE(560)] = 6446, + [SMALL_STATE(561)] = 6536, + [SMALL_STATE(562)] = 6712, + [SMALL_STATE(563)] = 6794, + [SMALL_STATE(564)] = 6938, + [SMALL_STATE(565)] = 7082, + [SMALL_STATE(566)] = 7218, + [SMALL_STATE(567)] = 7362, + [SMALL_STATE(568)] = 7506, + [SMALL_STATE(569)] = 7650, + [SMALL_STATE(570)] = 7784, + [SMALL_STATE(571)] = 7928, + [SMALL_STATE(572)] = 8072, + [SMALL_STATE(573)] = 8150, + [SMALL_STATE(574)] = 8294, + [SMALL_STATE(575)] = 8372, + [SMALL_STATE(576)] = 8516, + [SMALL_STATE(577)] = 8598, + [SMALL_STATE(578)] = 8771, + [SMALL_STATE(579)] = 8848, + [SMALL_STATE(580)] = 9021, + [SMALL_STATE(581)] = 9194, + [SMALL_STATE(582)] = 9367, + [SMALL_STATE(583)] = 9444, + [SMALL_STATE(584)] = 9615, + [SMALL_STATE(585)] = 9692, + [SMALL_STATE(586)] = 9863, + [SMALL_STATE(587)] = 9940, + [SMALL_STATE(588)] = 10017, + [SMALL_STATE(589)] = 10094, + [SMALL_STATE(590)] = 10267, + [SMALL_STATE(591)] = 10364, + [SMALL_STATE(592)] = 10537, + [SMALL_STATE(593)] = 10614, + [SMALL_STATE(594)] = 10691, + [SMALL_STATE(595)] = 10786, + [SMALL_STATE(596)] = 10959, + [SMALL_STATE(597)] = 11132, + [SMALL_STATE(598)] = 11305, + [SMALL_STATE(599)] = 11478, + [SMALL_STATE(600)] = 11555, + [SMALL_STATE(601)] = 11632, + [SMALL_STATE(602)] = 11709, + [SMALL_STATE(603)] = 11786, + [SMALL_STATE(604)] = 11863, + [SMALL_STATE(605)] = 11939, + [SMALL_STATE(606)] = 12027, + [SMALL_STATE(607)] = 12113, + [SMALL_STATE(608)] = 12188, + [SMALL_STATE(609)] = 12263, + [SMALL_STATE(610)] = 12342, + [SMALL_STATE(611)] = 12421, + [SMALL_STATE(612)] = 12500, + [SMALL_STATE(613)] = 12575, + [SMALL_STATE(614)] = 12650, + [SMALL_STATE(615)] = 12725, + [SMALL_STATE(616)] = 12800, + [SMALL_STATE(617)] = 12875, + [SMALL_STATE(618)] = 12966, + [SMALL_STATE(619)] = 13041, + [SMALL_STATE(620)] = 13116, + [SMALL_STATE(621)] = 13233, + [SMALL_STATE(622)] = 13328, + [SMALL_STATE(623)] = 13403, + [SMALL_STATE(624)] = 13478, + [SMALL_STATE(625)] = 13569, + [SMALL_STATE(626)] = 13644, + [SMALL_STATE(627)] = 13719, + [SMALL_STATE(628)] = 13794, + [SMALL_STATE(629)] = 13869, + [SMALL_STATE(630)] = 13944, + [SMALL_STATE(631)] = 14039, + [SMALL_STATE(632)] = 14132, + [SMALL_STATE(633)] = 14207, + [SMALL_STATE(634)] = 14282, + [SMALL_STATE(635)] = 14357, + [SMALL_STATE(636)] = 14432, + [SMALL_STATE(637)] = 14507, + [SMALL_STATE(638)] = 14582, + [SMALL_STATE(639)] = 14688, + [SMALL_STATE(640)] = 14762, + [SMALL_STATE(641)] = 14836, + [SMALL_STATE(642)] = 14910, + [SMALL_STATE(643)] = 15002, + [SMALL_STATE(644)] = 15108, + [SMALL_STATE(645)] = 15182, + [SMALL_STATE(646)] = 15256, + [SMALL_STATE(647)] = 15362, + [SMALL_STATE(648)] = 15450, + [SMALL_STATE(649)] = 15540, + [SMALL_STATE(650)] = 15614, + [SMALL_STATE(651)] = 15688, + [SMALL_STATE(652)] = 15778, + [SMALL_STATE(653)] = 15862, + [SMALL_STATE(654)] = 15936, + [SMALL_STATE(655)] = 16042, + [SMALL_STATE(656)] = 16116, + [SMALL_STATE(657)] = 16204, + [SMALL_STATE(658)] = 16278, + [SMALL_STATE(659)] = 16352, + [SMALL_STATE(660)] = 16426, + [SMALL_STATE(661)] = 16500, + [SMALL_STATE(662)] = 16573, + [SMALL_STATE(663)] = 16650, + [SMALL_STATE(664)] = 16755, + [SMALL_STATE(665)] = 16832, + [SMALL_STATE(666)] = 16935, + [SMALL_STATE(667)] = 17038, + [SMALL_STATE(668)] = 17137, + [SMALL_STATE(669)] = 17240, + [SMALL_STATE(670)] = 17313, + [SMALL_STATE(671)] = 17386, + [SMALL_STATE(672)] = 17491, + [SMALL_STATE(673)] = 17652, + [SMALL_STATE(674)] = 17729, + [SMALL_STATE(675)] = 17872, + [SMALL_STATE(676)] = 17975, + [SMALL_STATE(677)] = 18048, + [SMALL_STATE(678)] = 18137, + [SMALL_STATE(679)] = 18210, + [SMALL_STATE(680)] = 18312, + [SMALL_STATE(681)] = 18414, + [SMALL_STATE(682)] = 18500, + [SMALL_STATE(683)] = 18658, + [SMALL_STATE(684)] = 18785, + [SMALL_STATE(685)] = 18940, + [SMALL_STATE(686)] = 19095, + [SMALL_STATE(687)] = 19230, + [SMALL_STATE(688)] = 19373, + [SMALL_STATE(689)] = 19508, + [SMALL_STATE(690)] = 19611, + [SMALL_STATE(691)] = 19714, + [SMALL_STATE(692)] = 19817, + [SMALL_STATE(693)] = 19952, + [SMALL_STATE(694)] = 20087, + [SMALL_STATE(695)] = 20190, + [SMALL_STATE(696)] = 20333, + [SMALL_STATE(697)] = 20468, + [SMALL_STATE(698)] = 20603, + [SMALL_STATE(699)] = 20706, + [SMALL_STATE(700)] = 20809, + [SMALL_STATE(701)] = 20944, + [SMALL_STATE(702)] = 21099, + [SMALL_STATE(703)] = 21234, + [SMALL_STATE(704)] = 21363, + [SMALL_STATE(705)] = 21498, + [SMALL_STATE(706)] = 21598, + [SMALL_STATE(707)] = 21750, + [SMALL_STATE(708)] = 21850, + [SMALL_STATE(709)] = 21950, + [SMALL_STATE(710)] = 22050, + [SMALL_STATE(711)] = 22150, + [SMALL_STATE(712)] = 22250, + [SMALL_STATE(713)] = 22346, + [SMALL_STATE(714)] = 22481, + [SMALL_STATE(715)] = 22616, + [SMALL_STATE(716)] = 22751, + [SMALL_STATE(717)] = 22852, + [SMALL_STATE(718)] = 22953, + [SMALL_STATE(719)] = 23088, + [SMALL_STATE(720)] = 23223, + [SMALL_STATE(721)] = 23358, + [SMALL_STATE(722)] = 23493, + [SMALL_STATE(723)] = 23634, + [SMALL_STATE(724)] = 23769, + [SMALL_STATE(725)] = 23904, + [SMALL_STATE(726)] = 24031, + [SMALL_STATE(727)] = 24132, + [SMALL_STATE(728)] = 24233, + [SMALL_STATE(729)] = 24358, + [SMALL_STATE(730)] = 24426, + [SMALL_STATE(731)] = 24494, + [SMALL_STATE(732)] = 24562, + [SMALL_STATE(733)] = 24630, + [SMALL_STATE(734)] = 24698, + [SMALL_STATE(735)] = 24766, + [SMALL_STATE(736)] = 24864, + [SMALL_STATE(737)] = 24962, + [SMALL_STATE(738)] = 25030, + [SMALL_STATE(739)] = 25098, + [SMALL_STATE(740)] = 25166, + [SMALL_STATE(741)] = 25234, + [SMALL_STATE(742)] = 25302, + [SMALL_STATE(743)] = 25370, + [SMALL_STATE(744)] = 25438, + [SMALL_STATE(745)] = 25536, + [SMALL_STATE(746)] = 25634, + [SMALL_STATE(747)] = 25728, + [SMALL_STATE(748)] = 25796, + [SMALL_STATE(749)] = 25892, + [SMALL_STATE(750)] = 25960, + [SMALL_STATE(751)] = 26028, + [SMALL_STATE(752)] = 26096, + [SMALL_STATE(753)] = 26229, + [SMALL_STATE(754)] = 26360, + [SMALL_STATE(755)] = 26491, + [SMALL_STATE(756)] = 26622, + [SMALL_STATE(757)] = 26697, + [SMALL_STATE(758)] = 26776, + [SMALL_STATE(759)] = 26855, + [SMALL_STATE(760)] = 27000, + [SMALL_STATE(761)] = 27127, + [SMALL_STATE(762)] = 27272, + [SMALL_STATE(763)] = 27375, + [SMALL_STATE(764)] = 27506, + [SMALL_STATE(765)] = 27637, + [SMALL_STATE(766)] = 27712, + [SMALL_STATE(767)] = 27785, + [SMALL_STATE(768)] = 27910, + [SMALL_STATE(769)] = 28013, + [SMALL_STATE(770)] = 28144, + [SMALL_STATE(771)] = 28275, + [SMALL_STATE(772)] = 28406, + [SMALL_STATE(773)] = 28539, + [SMALL_STATE(774)] = 28662, + [SMALL_STATE(775)] = 28795, + [SMALL_STATE(776)] = 28920, + [SMALL_STATE(777)] = 29053, + [SMALL_STATE(778)] = 29186, + [SMALL_STATE(779)] = 29309, + [SMALL_STATE(780)] = 29442, + [SMALL_STATE(781)] = 29575, + [SMALL_STATE(782)] = 29708, + [SMALL_STATE(783)] = 29841, + [SMALL_STATE(784)] = 29972, + [SMALL_STATE(785)] = 30038, + [SMALL_STATE(786)] = 30104, + [SMALL_STATE(787)] = 30180, + [SMALL_STATE(788)] = 30322, + [SMALL_STATE(789)] = 30396, + [SMALL_STATE(790)] = 30470, + [SMALL_STATE(791)] = 30536, + [SMALL_STATE(792)] = 30602, + [SMALL_STATE(793)] = 30668, + [SMALL_STATE(794)] = 30734, + [SMALL_STATE(795)] = 30800, + [SMALL_STATE(796)] = 30866, + [SMALL_STATE(797)] = 30932, + [SMALL_STATE(798)] = 30998, + [SMALL_STATE(799)] = 31072, + [SMALL_STATE(800)] = 31138, + [SMALL_STATE(801)] = 31280, + [SMALL_STATE(802)] = 31352, + [SMALL_STATE(803)] = 31426, + [SMALL_STATE(804)] = 31498, + [SMALL_STATE(805)] = 31572, + [SMALL_STATE(806)] = 31708, + [SMALL_STATE(807)] = 31782, + [SMALL_STATE(808)] = 31918, + [SMALL_STATE(809)] = 31984, + [SMALL_STATE(810)] = 32058, + [SMALL_STATE(811)] = 32124, + [SMALL_STATE(812)] = 32190, + [SMALL_STATE(813)] = 32256, + [SMALL_STATE(814)] = 32322, + [SMALL_STATE(815)] = 32388, + [SMALL_STATE(816)] = 32530, + [SMALL_STATE(817)] = 32599, + [SMALL_STATE(818)] = 32668, + [SMALL_STATE(819)] = 32737, + [SMALL_STATE(820)] = 32806, + [SMALL_STATE(821)] = 32879, + [SMALL_STATE(822)] = 32948, + [SMALL_STATE(823)] = 33019, + [SMALL_STATE(824)] = 33088, + [SMALL_STATE(825)] = 33157, + [SMALL_STATE(826)] = 33296, + [SMALL_STATE(827)] = 33365, + [SMALL_STATE(828)] = 33468, + [SMALL_STATE(829)] = 33539, + [SMALL_STATE(830)] = 33642, + [SMALL_STATE(831)] = 33781, + [SMALL_STATE(832)] = 33920, + [SMALL_STATE(833)] = 33989, + [SMALL_STATE(834)] = 34058, + [SMALL_STATE(835)] = 34127, + [SMALL_STATE(836)] = 34196, + [SMALL_STATE(837)] = 34260, + [SMALL_STATE(838)] = 34326, + [SMALL_STATE(839)] = 34392, + [SMALL_STATE(840)] = 34460, + [SMALL_STATE(841)] = 34526, + [SMALL_STATE(842)] = 34592, + [SMALL_STATE(843)] = 34658, + [SMALL_STATE(844)] = 34724, + [SMALL_STATE(845)] = 34788, + [SMALL_STATE(846)] = 34852, + [SMALL_STATE(847)] = 34918, + [SMALL_STATE(848)] = 34984, + [SMALL_STATE(849)] = 35050, + [SMALL_STATE(850)] = 35116, + [SMALL_STATE(851)] = 35182, + [SMALL_STATE(852)] = 35248, + [SMALL_STATE(853)] = 35312, + [SMALL_STATE(854)] = 35376, + [SMALL_STATE(855)] = 35442, + [SMALL_STATE(856)] = 35506, + [SMALL_STATE(857)] = 35570, + [SMALL_STATE(858)] = 35634, + [SMALL_STATE(859)] = 35698, + [SMALL_STATE(860)] = 35762, + [SMALL_STATE(861)] = 35826, + [SMALL_STATE(862)] = 35890, + [SMALL_STATE(863)] = 35954, + [SMALL_STATE(864)] = 36022, + [SMALL_STATE(865)] = 36086, + [SMALL_STATE(866)] = 36150, + [SMALL_STATE(867)] = 36214, + [SMALL_STATE(868)] = 36278, + [SMALL_STATE(869)] = 36344, + [SMALL_STATE(870)] = 36412, + [SMALL_STATE(871)] = 36476, + [SMALL_STATE(872)] = 36540, + [SMALL_STATE(873)] = 36604, + [SMALL_STATE(874)] = 36668, + [SMALL_STATE(875)] = 36734, + [SMALL_STATE(876)] = 36798, + [SMALL_STATE(877)] = 36934, + [SMALL_STATE(878)] = 36998, + [SMALL_STATE(879)] = 37062, + [SMALL_STATE(880)] = 37126, + [SMALL_STATE(881)] = 37190, + [SMALL_STATE(882)] = 37254, + [SMALL_STATE(883)] = 37318, + [SMALL_STATE(884)] = 37382, + [SMALL_STATE(885)] = 37446, + [SMALL_STATE(886)] = 37510, + [SMALL_STATE(887)] = 37576, + [SMALL_STATE(888)] = 37650, + [SMALL_STATE(889)] = 37722, + [SMALL_STATE(890)] = 37794, + [SMALL_STATE(891)] = 37864, + [SMALL_STATE(892)] = 37940, + [SMALL_STATE(893)] = 38016, + [SMALL_STATE(894)] = 38090, + [SMALL_STATE(895)] = 38226, + [SMALL_STATE(896)] = 38290, + [SMALL_STATE(897)] = 38354, + [SMALL_STATE(898)] = 38420, + [SMALL_STATE(899)] = 38484, + [SMALL_STATE(900)] = 38548, + [SMALL_STATE(901)] = 38611, + [SMALL_STATE(902)] = 38674, + [SMALL_STATE(903)] = 38737, + [SMALL_STATE(904)] = 38800, + [SMALL_STATE(905)] = 38863, + [SMALL_STATE(906)] = 38926, + [SMALL_STATE(907)] = 38989, + [SMALL_STATE(908)] = 39052, + [SMALL_STATE(909)] = 39115, + [SMALL_STATE(910)] = 39178, + [SMALL_STATE(911)] = 39241, + [SMALL_STATE(912)] = 39304, + [SMALL_STATE(913)] = 39379, + [SMALL_STATE(914)] = 39442, + [SMALL_STATE(915)] = 39505, + [SMALL_STATE(916)] = 39568, + [SMALL_STATE(917)] = 39631, + [SMALL_STATE(918)] = 39694, + [SMALL_STATE(919)] = 39757, + [SMALL_STATE(920)] = 39820, + [SMALL_STATE(921)] = 39883, + [SMALL_STATE(922)] = 39946, + [SMALL_STATE(923)] = 40009, + [SMALL_STATE(924)] = 40072, + [SMALL_STATE(925)] = 40135, + [SMALL_STATE(926)] = 40198, + [SMALL_STATE(927)] = 40261, + [SMALL_STATE(928)] = 40324, + [SMALL_STATE(929)] = 40387, + [SMALL_STATE(930)] = 40450, + [SMALL_STATE(931)] = 40513, + [SMALL_STATE(932)] = 40576, + [SMALL_STATE(933)] = 40639, + [SMALL_STATE(934)] = 40702, + [SMALL_STATE(935)] = 40765, + [SMALL_STATE(936)] = 40828, + [SMALL_STATE(937)] = 40891, + [SMALL_STATE(938)] = 40954, + [SMALL_STATE(939)] = 41017, + [SMALL_STATE(940)] = 41080, + [SMALL_STATE(941)] = 41143, + [SMALL_STATE(942)] = 41206, + [SMALL_STATE(943)] = 41269, + [SMALL_STATE(944)] = 41332, + [SMALL_STATE(945)] = 41395, + [SMALL_STATE(946)] = 41458, + [SMALL_STATE(947)] = 41521, + [SMALL_STATE(948)] = 41584, + [SMALL_STATE(949)] = 41657, + [SMALL_STATE(950)] = 41720, + [SMALL_STATE(951)] = 41783, + [SMALL_STATE(952)] = 41852, + [SMALL_STATE(953)] = 41915, + [SMALL_STATE(954)] = 41990, + [SMALL_STATE(955)] = 42053, + [SMALL_STATE(956)] = 42132, + [SMALL_STATE(957)] = 42195, + [SMALL_STATE(958)] = 42266, + [SMALL_STATE(959)] = 42337, + [SMALL_STATE(960)] = 42400, + [SMALL_STATE(961)] = 42471, + [SMALL_STATE(962)] = 42534, + [SMALL_STATE(963)] = 42597, + [SMALL_STATE(964)] = 42666, + [SMALL_STATE(965)] = 42729, + [SMALL_STATE(966)] = 42800, + [SMALL_STATE(967)] = 42871, + [SMALL_STATE(968)] = 42942, + [SMALL_STATE(969)] = 43013, + [SMALL_STATE(970)] = 43080, + [SMALL_STATE(971)] = 43147, + [SMALL_STATE(972)] = 43214, + [SMALL_STATE(973)] = 43277, + [SMALL_STATE(974)] = 43410, + [SMALL_STATE(975)] = 43473, + [SMALL_STATE(976)] = 43536, + [SMALL_STATE(977)] = 43599, + [SMALL_STATE(978)] = 43662, + [SMALL_STATE(979)] = 43725, + [SMALL_STATE(980)] = 43788, + [SMALL_STATE(981)] = 43851, + [SMALL_STATE(982)] = 43914, + [SMALL_STATE(983)] = 43977, + [SMALL_STATE(984)] = 44110, + [SMALL_STATE(985)] = 44173, + [SMALL_STATE(986)] = 44236, + [SMALL_STATE(987)] = 44369, + [SMALL_STATE(988)] = 44432, + [SMALL_STATE(989)] = 44495, + [SMALL_STATE(990)] = 44558, + [SMALL_STATE(991)] = 44621, + [SMALL_STATE(992)] = 44696, + [SMALL_STATE(993)] = 44759, + [SMALL_STATE(994)] = 44822, + [SMALL_STATE(995)] = 44885, + [SMALL_STATE(996)] = 44948, + [SMALL_STATE(997)] = 45011, + [SMALL_STATE(998)] = 45074, + [SMALL_STATE(999)] = 45137, + [SMALL_STATE(1000)] = 45200, + [SMALL_STATE(1001)] = 45263, + [SMALL_STATE(1002)] = 45326, + [SMALL_STATE(1003)] = 45389, + [SMALL_STATE(1004)] = 45452, + [SMALL_STATE(1005)] = 45515, + [SMALL_STATE(1006)] = 45578, + [SMALL_STATE(1007)] = 45641, + [SMALL_STATE(1008)] = 45709, + [SMALL_STATE(1009)] = 45775, + [SMALL_STATE(1010)] = 45841, + [SMALL_STATE(1011)] = 45907, + [SMALL_STATE(1012)] = 45975, + [SMALL_STATE(1013)] = 46049, + [SMALL_STATE(1014)] = 46115, + [SMALL_STATE(1015)] = 46181, + [SMALL_STATE(1016)] = 46251, + [SMALL_STATE(1017)] = 46319, + [SMALL_STATE(1018)] = 46385, + [SMALL_STATE(1019)] = 46453, + [SMALL_STATE(1020)] = 46519, + [SMALL_STATE(1021)] = 46585, + [SMALL_STATE(1022)] = 46651, + [SMALL_STATE(1023)] = 46717, + [SMALL_STATE(1024)] = 46783, + [SMALL_STATE(1025)] = 46849, + [SMALL_STATE(1026)] = 46917, + [SMALL_STATE(1027)] = 46985, + [SMALL_STATE(1028)] = 47048, + [SMALL_STATE(1029)] = 47109, + [SMALL_STATE(1030)] = 47172, + [SMALL_STATE(1031)] = 47233, + [SMALL_STATE(1032)] = 47294, + [SMALL_STATE(1033)] = 47355, + [SMALL_STATE(1034)] = 47440, + [SMALL_STATE(1035)] = 47501, + [SMALL_STATE(1036)] = 47584, + [SMALL_STATE(1037)] = 47647, + [SMALL_STATE(1038)] = 47710, + [SMALL_STATE(1039)] = 47773, + [SMALL_STATE(1040)] = 47838, + [SMALL_STATE(1041)] = 47901, + [SMALL_STATE(1042)] = 47962, + [SMALL_STATE(1043)] = 48023, + [SMALL_STATE(1044)] = 48086, + [SMALL_STATE(1045)] = 48147, + [SMALL_STATE(1046)] = 48208, + [SMALL_STATE(1047)] = 48269, + [SMALL_STATE(1048)] = 48330, + [SMALL_STATE(1049)] = 48391, + [SMALL_STATE(1050)] = 48452, + [SMALL_STATE(1051)] = 48525, + [SMALL_STATE(1052)] = 48586, + [SMALL_STATE(1053)] = 48657, + [SMALL_STATE(1054)] = 48720, + [SMALL_STATE(1055)] = 48783, + [SMALL_STATE(1056)] = 48844, + [SMALL_STATE(1057)] = 48905, + [SMALL_STATE(1058)] = 48966, + [SMALL_STATE(1059)] = 49031, + [SMALL_STATE(1060)] = 49158, + [SMALL_STATE(1061)] = 49219, + [SMALL_STATE(1062)] = 49282, + [SMALL_STATE(1063)] = 49343, + [SMALL_STATE(1064)] = 49404, + [SMALL_STATE(1065)] = 49465, + [SMALL_STATE(1066)] = 49526, + [SMALL_STATE(1067)] = 49587, + [SMALL_STATE(1068)] = 49648, + [SMALL_STATE(1069)] = 49711, + [SMALL_STATE(1070)] = 49774, + [SMALL_STATE(1071)] = 49901, + [SMALL_STATE(1072)] = 49962, + [SMALL_STATE(1073)] = 50023, + [SMALL_STATE(1074)] = 50086, + [SMALL_STATE(1075)] = 50147, + [SMALL_STATE(1076)] = 50208, + [SMALL_STATE(1077)] = 50269, + [SMALL_STATE(1078)] = 50330, + [SMALL_STATE(1079)] = 50457, + [SMALL_STATE(1080)] = 50520, + [SMALL_STATE(1081)] = 50581, + [SMALL_STATE(1082)] = 50666, + [SMALL_STATE(1083)] = 50727, + [SMALL_STATE(1084)] = 50788, + [SMALL_STATE(1085)] = 50851, + [SMALL_STATE(1086)] = 50912, + [SMALL_STATE(1087)] = 50977, + [SMALL_STATE(1088)] = 51040, + [SMALL_STATE(1089)] = 51101, + [SMALL_STATE(1090)] = 51164, + [SMALL_STATE(1091)] = 51224, + [SMALL_STATE(1092)] = 51294, + [SMALL_STATE(1093)] = 51354, + [SMALL_STATE(1094)] = 51414, + [SMALL_STATE(1095)] = 51474, + [SMALL_STATE(1096)] = 51534, + [SMALL_STATE(1097)] = 51594, + [SMALL_STATE(1098)] = 51654, + [SMALL_STATE(1099)] = 51714, + [SMALL_STATE(1100)] = 51774, + [SMALL_STATE(1101)] = 51834, + [SMALL_STATE(1102)] = 51894, + [SMALL_STATE(1103)] = 51954, + [SMALL_STATE(1104)] = 52014, + [SMALL_STATE(1105)] = 52074, + [SMALL_STATE(1106)] = 52134, + [SMALL_STATE(1107)] = 52194, + [SMALL_STATE(1108)] = 52254, + [SMALL_STATE(1109)] = 52314, + [SMALL_STATE(1110)] = 52374, + [SMALL_STATE(1111)] = 52434, + [SMALL_STATE(1112)] = 52494, + [SMALL_STATE(1113)] = 52554, + [SMALL_STATE(1114)] = 52614, + [SMALL_STATE(1115)] = 52674, + [SMALL_STATE(1116)] = 52734, + [SMALL_STATE(1117)] = 52794, + [SMALL_STATE(1118)] = 52854, + [SMALL_STATE(1119)] = 52914, + [SMALL_STATE(1120)] = 52974, + [SMALL_STATE(1121)] = 53034, + [SMALL_STATE(1122)] = 53094, + [SMALL_STATE(1123)] = 53154, + [SMALL_STATE(1124)] = 53214, + [SMALL_STATE(1125)] = 53274, + [SMALL_STATE(1126)] = 53334, + [SMALL_STATE(1127)] = 53394, + [SMALL_STATE(1128)] = 53454, + [SMALL_STATE(1129)] = 53514, + [SMALL_STATE(1130)] = 53574, + [SMALL_STATE(1131)] = 53634, + [SMALL_STATE(1132)] = 53694, + [SMALL_STATE(1133)] = 53754, + [SMALL_STATE(1134)] = 53814, + [SMALL_STATE(1135)] = 53874, + [SMALL_STATE(1136)] = 53934, + [SMALL_STATE(1137)] = 53994, + [SMALL_STATE(1138)] = 54054, + [SMALL_STATE(1139)] = 54122, + [SMALL_STATE(1140)] = 54182, + [SMALL_STATE(1141)] = 54242, + [SMALL_STATE(1142)] = 54302, + [SMALL_STATE(1143)] = 54362, + [SMALL_STATE(1144)] = 54422, + [SMALL_STATE(1145)] = 54482, + [SMALL_STATE(1146)] = 54542, + [SMALL_STATE(1147)] = 54602, + [SMALL_STATE(1148)] = 54662, + [SMALL_STATE(1149)] = 54722, + [SMALL_STATE(1150)] = 54782, + [SMALL_STATE(1151)] = 54842, + [SMALL_STATE(1152)] = 54902, + [SMALL_STATE(1153)] = 54962, + [SMALL_STATE(1154)] = 55022, + [SMALL_STATE(1155)] = 55082, + [SMALL_STATE(1156)] = 55142, + [SMALL_STATE(1157)] = 55202, + [SMALL_STATE(1158)] = 55262, + [SMALL_STATE(1159)] = 55322, + [SMALL_STATE(1160)] = 55382, + [SMALL_STATE(1161)] = 55442, + [SMALL_STATE(1162)] = 55508, + [SMALL_STATE(1163)] = 55574, + [SMALL_STATE(1164)] = 55640, + [SMALL_STATE(1165)] = 55700, + [SMALL_STATE(1166)] = 55760, + [SMALL_STATE(1167)] = 55820, + [SMALL_STATE(1168)] = 55880, + [SMALL_STATE(1169)] = 55940, + [SMALL_STATE(1170)] = 56000, + [SMALL_STATE(1171)] = 56060, + [SMALL_STATE(1172)] = 56124, + [SMALL_STATE(1173)] = 56188, + [SMALL_STATE(1174)] = 56248, + [SMALL_STATE(1175)] = 56308, + [SMALL_STATE(1176)] = 56372, + [SMALL_STATE(1177)] = 56432, + [SMALL_STATE(1178)] = 56492, + [SMALL_STATE(1179)] = 56552, + [SMALL_STATE(1180)] = 56612, + [SMALL_STATE(1181)] = 56672, + [SMALL_STATE(1182)] = 56732, + [SMALL_STATE(1183)] = 56792, + [SMALL_STATE(1184)] = 56852, + [SMALL_STATE(1185)] = 56912, + [SMALL_STATE(1186)] = 56972, + [SMALL_STATE(1187)] = 57032, + [SMALL_STATE(1188)] = 57092, + [SMALL_STATE(1189)] = 57152, + [SMALL_STATE(1190)] = 57212, + [SMALL_STATE(1191)] = 57272, + [SMALL_STATE(1192)] = 57332, + [SMALL_STATE(1193)] = 57392, + [SMALL_STATE(1194)] = 57452, + [SMALL_STATE(1195)] = 57512, + [SMALL_STATE(1196)] = 57582, + [SMALL_STATE(1197)] = 57642, + [SMALL_STATE(1198)] = 57702, + [SMALL_STATE(1199)] = 57762, + [SMALL_STATE(1200)] = 57822, + [SMALL_STATE(1201)] = 57882, + [SMALL_STATE(1202)] = 57942, + [SMALL_STATE(1203)] = 58010, + [SMALL_STATE(1204)] = 58070, + [SMALL_STATE(1205)] = 58130, + [SMALL_STATE(1206)] = 58193, + [SMALL_STATE(1207)] = 58252, + [SMALL_STATE(1208)] = 58311, + [SMALL_STATE(1209)] = 58370, + [SMALL_STATE(1210)] = 58429, + [SMALL_STATE(1211)] = 58490, + [SMALL_STATE(1212)] = 58555, + [SMALL_STATE(1213)] = 58616, + [SMALL_STATE(1214)] = 58699, + [SMALL_STATE(1215)] = 58782, + [SMALL_STATE(1216)] = 58845, + [SMALL_STATE(1217)] = 58910, + [SMALL_STATE(1218)] = 58971, + [SMALL_STATE(1219)] = 59036, + [SMALL_STATE(1220)] = 59105, + [SMALL_STATE(1221)] = 59190, + [SMALL_STATE(1222)] = 59255, + [SMALL_STATE(1223)] = 59340, + [SMALL_STATE(1224)] = 59399, + [SMALL_STATE(1225)] = 59470, + [SMALL_STATE(1226)] = 59537, + [SMALL_STATE(1227)] = 59597, + [SMALL_STATE(1228)] = 59655, + [SMALL_STATE(1229)] = 59713, + [SMALL_STATE(1230)] = 59771, + [SMALL_STATE(1231)] = 59829, + [SMALL_STATE(1232)] = 59887, + [SMALL_STATE(1233)] = 59945, + [SMALL_STATE(1234)] = 60003, + [SMALL_STATE(1235)] = 60061, + [SMALL_STATE(1236)] = 60119, + [SMALL_STATE(1237)] = 60177, + [SMALL_STATE(1238)] = 60235, + [SMALL_STATE(1239)] = 60303, + [SMALL_STATE(1240)] = 60361, + [SMALL_STATE(1241)] = 60419, + [SMALL_STATE(1242)] = 60477, + [SMALL_STATE(1243)] = 60535, + [SMALL_STATE(1244)] = 60593, + [SMALL_STATE(1245)] = 60663, + [SMALL_STATE(1246)] = 60721, + [SMALL_STATE(1247)] = 60779, + [SMALL_STATE(1248)] = 60837, + [SMALL_STATE(1249)] = 60895, + [SMALL_STATE(1250)] = 60963, + [SMALL_STATE(1251)] = 61027, + [SMALL_STATE(1252)] = 61091, + [SMALL_STATE(1253)] = 61149, + [SMALL_STATE(1254)] = 61207, + [SMALL_STATE(1255)] = 61265, + [SMALL_STATE(1256)] = 61323, + [SMALL_STATE(1257)] = 61389, + [SMALL_STATE(1258)] = 61447, + [SMALL_STATE(1259)] = 61505, + [SMALL_STATE(1260)] = 61567, + [SMALL_STATE(1261)] = 61629, + [SMALL_STATE(1262)] = 61687, + [SMALL_STATE(1263)] = 61745, + [SMALL_STATE(1264)] = 61803, + [SMALL_STATE(1265)] = 61861, + [SMALL_STATE(1266)] = 61919, + [SMALL_STATE(1267)] = 61977, + [SMALL_STATE(1268)] = 62041, + [SMALL_STATE(1269)] = 62103, + [SMALL_STATE(1270)] = 62165, + [SMALL_STATE(1271)] = 62223, + [SMALL_STATE(1272)] = 62281, + [SMALL_STATE(1273)] = 62339, + [SMALL_STATE(1274)] = 62397, + [SMALL_STATE(1275)] = 62455, + [SMALL_STATE(1276)] = 62525, + [SMALL_STATE(1277)] = 62583, + [SMALL_STATE(1278)] = 62641, + [SMALL_STATE(1279)] = 62703, + [SMALL_STATE(1280)] = 62761, + [SMALL_STATE(1281)] = 62823, + [SMALL_STATE(1282)] = 62881, + [SMALL_STATE(1283)] = 62939, + [SMALL_STATE(1284)] = 62997, + [SMALL_STATE(1285)] = 63055, + [SMALL_STATE(1286)] = 63113, + [SMALL_STATE(1287)] = 63171, + [SMALL_STATE(1288)] = 63229, + [SMALL_STATE(1289)] = 63287, + [SMALL_STATE(1290)] = 63345, + [SMALL_STATE(1291)] = 63403, + [SMALL_STATE(1292)] = 63471, + [SMALL_STATE(1293)] = 63533, + [SMALL_STATE(1294)] = 63591, + [SMALL_STATE(1295)] = 63653, + [SMALL_STATE(1296)] = 63711, + [SMALL_STATE(1297)] = 63769, + [SMALL_STATE(1298)] = 63831, + [SMALL_STATE(1299)] = 63889, + [SMALL_STATE(1300)] = 63947, + [SMALL_STATE(1301)] = 64005, + [SMALL_STATE(1302)] = 64063, + [SMALL_STATE(1303)] = 64121, + [SMALL_STATE(1304)] = 64183, + [SMALL_STATE(1305)] = 64241, + [SMALL_STATE(1306)] = 64299, + [SMALL_STATE(1307)] = 64357, + [SMALL_STATE(1308)] = 64415, + [SMALL_STATE(1309)] = 64473, + [SMALL_STATE(1310)] = 64531, + [SMALL_STATE(1311)] = 64589, + [SMALL_STATE(1312)] = 64647, + [SMALL_STATE(1313)] = 64705, + [SMALL_STATE(1314)] = 64762, + [SMALL_STATE(1315)] = 64819, + [SMALL_STATE(1316)] = 64884, + [SMALL_STATE(1317)] = 64949, + [SMALL_STATE(1318)] = 65006, + [SMALL_STATE(1319)] = 65063, + [SMALL_STATE(1320)] = 65120, + [SMALL_STATE(1321)] = 65177, + [SMALL_STATE(1322)] = 65234, + [SMALL_STATE(1323)] = 65291, + [SMALL_STATE(1324)] = 65356, + [SMALL_STATE(1325)] = 65417, + [SMALL_STATE(1326)] = 65482, + [SMALL_STATE(1327)] = 65543, + [SMALL_STATE(1328)] = 65600, + [SMALL_STATE(1329)] = 65665, + [SMALL_STATE(1330)] = 65728, + [SMALL_STATE(1331)] = 65793, + [SMALL_STATE(1332)] = 65856, + [SMALL_STATE(1333)] = 65917, + [SMALL_STATE(1334)] = 65978, + [SMALL_STATE(1335)] = 66039, + [SMALL_STATE(1336)] = 66096, + [SMALL_STATE(1337)] = 66157, + [SMALL_STATE(1338)] = 66218, + [SMALL_STATE(1339)] = 66324, + [SMALL_STATE(1340)] = 66388, + [SMALL_STATE(1341)] = 66494, + [SMALL_STATE(1342)] = 66562, + [SMALL_STATE(1343)] = 66630, + [SMALL_STATE(1344)] = 66686, + [SMALL_STATE(1345)] = 66750, + [SMALL_STATE(1346)] = 66806, + [SMALL_STATE(1347)] = 66862, + [SMALL_STATE(1348)] = 66918, + [SMALL_STATE(1349)] = 67024, + [SMALL_STATE(1350)] = 67090, + [SMALL_STATE(1351)] = 67146, + [SMALL_STATE(1352)] = 67206, + [SMALL_STATE(1353)] = 67272, + [SMALL_STATE(1354)] = 67378, + [SMALL_STATE(1355)] = 67434, + [SMALL_STATE(1356)] = 67540, + [SMALL_STATE(1357)] = 67606, + [SMALL_STATE(1358)] = 67662, + [SMALL_STATE(1359)] = 67768, + [SMALL_STATE(1360)] = 67824, + [SMALL_STATE(1361)] = 67930, + [SMALL_STATE(1362)] = 67986, + [SMALL_STATE(1363)] = 68092, + [SMALL_STATE(1364)] = 68198, + [SMALL_STATE(1365)] = 68262, + [SMALL_STATE(1366)] = 68368, + [SMALL_STATE(1367)] = 68474, + [SMALL_STATE(1368)] = 68580, + [SMALL_STATE(1369)] = 68686, + [SMALL_STATE(1370)] = 68792, + [SMALL_STATE(1371)] = 68858, + [SMALL_STATE(1372)] = 68964, + [SMALL_STATE(1373)] = 69020, + [SMALL_STATE(1374)] = 69082, + [SMALL_STATE(1375)] = 69138, + [SMALL_STATE(1376)] = 69193, + [SMALL_STATE(1377)] = 69252, + [SMALL_STATE(1378)] = 69315, + [SMALL_STATE(1379)] = 69426, + [SMALL_STATE(1380)] = 69487, + [SMALL_STATE(1381)] = 69542, + [SMALL_STATE(1382)] = 69605, + [SMALL_STATE(1383)] = 69668, + [SMALL_STATE(1384)] = 69731, + [SMALL_STATE(1385)] = 69792, + [SMALL_STATE(1386)] = 69863, + [SMALL_STATE(1387)] = 69918, + [SMALL_STATE(1388)] = 69973, + [SMALL_STATE(1389)] = 70032, + [SMALL_STATE(1390)] = 70091, + [SMALL_STATE(1391)] = 70146, + [SMALL_STATE(1392)] = 70201, + [SMALL_STATE(1393)] = 70256, + [SMALL_STATE(1394)] = 70311, + [SMALL_STATE(1395)] = 70366, + [SMALL_STATE(1396)] = 70425, + [SMALL_STATE(1397)] = 70484, + [SMALL_STATE(1398)] = 70543, + [SMALL_STATE(1399)] = 70598, + [SMALL_STATE(1400)] = 70661, + [SMALL_STATE(1401)] = 70726, + [SMALL_STATE(1402)] = 70781, + [SMALL_STATE(1403)] = 70836, + [SMALL_STATE(1404)] = 70891, + [SMALL_STATE(1405)] = 70946, + [SMALL_STATE(1406)] = 71001, + [SMALL_STATE(1407)] = 71060, + [SMALL_STATE(1408)] = 71115, + [SMALL_STATE(1409)] = 71174, + [SMALL_STATE(1410)] = 71233, + [SMALL_STATE(1411)] = 71296, + [SMALL_STATE(1412)] = 71351, + [SMALL_STATE(1413)] = 71410, + [SMALL_STATE(1414)] = 71481, + [SMALL_STATE(1415)] = 71536, + [SMALL_STATE(1416)] = 71591, + [SMALL_STATE(1417)] = 71647, + [SMALL_STATE(1418)] = 71713, + [SMALL_STATE(1419)] = 71767, + [SMALL_STATE(1420)] = 71821, + [SMALL_STATE(1421)] = 71875, + [SMALL_STATE(1422)] = 71929, + [SMALL_STATE(1423)] = 71983, + [SMALL_STATE(1424)] = 72037, + [SMALL_STATE(1425)] = 72099, + [SMALL_STATE(1426)] = 72153, + [SMALL_STATE(1427)] = 72209, + [SMALL_STATE(1428)] = 72267, + [SMALL_STATE(1429)] = 72321, + [SMALL_STATE(1430)] = 72379, + [SMALL_STATE(1431)] = 72433, + [SMALL_STATE(1432)] = 72495, + [SMALL_STATE(1433)] = 72549, + [SMALL_STATE(1434)] = 72603, + [SMALL_STATE(1435)] = 72657, + [SMALL_STATE(1436)] = 72723, + [SMALL_STATE(1437)] = 72777, + [SMALL_STATE(1438)] = 72837, + [SMALL_STATE(1439)] = 72891, + [SMALL_STATE(1440)] = 72947, + [SMALL_STATE(1441)] = 73001, + [SMALL_STATE(1442)] = 73055, + [SMALL_STATE(1443)] = 73109, + [SMALL_STATE(1444)] = 73163, + [SMALL_STATE(1445)] = 73217, + [SMALL_STATE(1446)] = 73271, + [SMALL_STATE(1447)] = 73325, + [SMALL_STATE(1448)] = 73381, + [SMALL_STATE(1449)] = 73435, + [SMALL_STATE(1450)] = 73491, + [SMALL_STATE(1451)] = 73547, + [SMALL_STATE(1452)] = 73601, + [SMALL_STATE(1453)] = 73667, + [SMALL_STATE(1454)] = 73721, + [SMALL_STATE(1455)] = 73777, + [SMALL_STATE(1456)] = 73833, + [SMALL_STATE(1457)] = 73889, + [SMALL_STATE(1458)] = 73943, + [SMALL_STATE(1459)] = 73997, + [SMALL_STATE(1460)] = 74051, + [SMALL_STATE(1461)] = 74105, + [SMALL_STATE(1462)] = 74161, + [SMALL_STATE(1463)] = 74230, + [SMALL_STATE(1464)] = 74287, + [SMALL_STATE(1465)] = 74340, + [SMALL_STATE(1466)] = 74397, + [SMALL_STATE(1467)] = 74454, + [SMALL_STATE(1468)] = 74507, + [SMALL_STATE(1469)] = 74564, + [SMALL_STATE(1470)] = 74617, + [SMALL_STATE(1471)] = 74674, + [SMALL_STATE(1472)] = 74731, + [SMALL_STATE(1473)] = 74792, + [SMALL_STATE(1474)] = 74845, + [SMALL_STATE(1475)] = 74898, + [SMALL_STATE(1476)] = 74955, + [SMALL_STATE(1477)] = 75008, + [SMALL_STATE(1478)] = 75065, + [SMALL_STATE(1479)] = 75122, + [SMALL_STATE(1480)] = 75191, + [SMALL_STATE(1481)] = 75244, + [SMALL_STATE(1482)] = 75309, + [SMALL_STATE(1483)] = 75362, + [SMALL_STATE(1484)] = 75423, + [SMALL_STATE(1485)] = 75482, + [SMALL_STATE(1486)] = 75543, + [SMALL_STATE(1487)] = 75596, + [SMALL_STATE(1488)] = 75667, + [SMALL_STATE(1489)] = 75720, + [SMALL_STATE(1490)] = 75773, + [SMALL_STATE(1491)] = 75826, + [SMALL_STATE(1492)] = 75891, + [SMALL_STATE(1493)] = 75948, + [SMALL_STATE(1494)] = 76009, + [SMALL_STATE(1495)] = 76062, + [SMALL_STATE(1496)] = 76115, + [SMALL_STATE(1497)] = 76168, + [SMALL_STATE(1498)] = 76221, + [SMALL_STATE(1499)] = 76282, + [SMALL_STATE(1500)] = 76335, + [SMALL_STATE(1501)] = 76388, + [SMALL_STATE(1502)] = 76449, + [SMALL_STATE(1503)] = 76514, + [SMALL_STATE(1504)] = 76567, + [SMALL_STATE(1505)] = 76620, + [SMALL_STATE(1506)] = 76673, + [SMALL_STATE(1507)] = 76726, + [SMALL_STATE(1508)] = 76779, + [SMALL_STATE(1509)] = 76836, + [SMALL_STATE(1510)] = 76889, + [SMALL_STATE(1511)] = 76948, + [SMALL_STATE(1512)] = 77007, + [SMALL_STATE(1513)] = 77060, + [SMALL_STATE(1514)] = 77112, + [SMALL_STATE(1515)] = 77164, + [SMALL_STATE(1516)] = 77216, + [SMALL_STATE(1517)] = 77268, + [SMALL_STATE(1518)] = 77320, + [SMALL_STATE(1519)] = 77372, + [SMALL_STATE(1520)] = 77426, + [SMALL_STATE(1521)] = 77478, + [SMALL_STATE(1522)] = 77534, + [SMALL_STATE(1523)] = 77586, + [SMALL_STATE(1524)] = 77666, + [SMALL_STATE(1525)] = 77722, + [SMALL_STATE(1526)] = 77776, + [SMALL_STATE(1527)] = 77828, + [SMALL_STATE(1528)] = 77880, + [SMALL_STATE(1529)] = 77932, + [SMALL_STATE(1530)] = 77984, + [SMALL_STATE(1531)] = 78044, + [SMALL_STATE(1532)] = 78098, + [SMALL_STATE(1533)] = 78152, + [SMALL_STATE(1534)] = 78206, + [SMALL_STATE(1535)] = 78260, + [SMALL_STATE(1536)] = 78312, + [SMALL_STATE(1537)] = 78392, + [SMALL_STATE(1538)] = 78444, + [SMALL_STATE(1539)] = 78502, + [SMALL_STATE(1540)] = 78562, + [SMALL_STATE(1541)] = 78614, + [SMALL_STATE(1542)] = 78666, + [SMALL_STATE(1543)] = 78718, + [SMALL_STATE(1544)] = 78770, + [SMALL_STATE(1545)] = 78822, + [SMALL_STATE(1546)] = 78874, + [SMALL_STATE(1547)] = 78926, + [SMALL_STATE(1548)] = 78978, + [SMALL_STATE(1549)] = 79036, + [SMALL_STATE(1550)] = 79096, + [SMALL_STATE(1551)] = 79150, + [SMALL_STATE(1552)] = 79202, + [SMALL_STATE(1553)] = 79254, + [SMALL_STATE(1554)] = 79306, + [SMALL_STATE(1555)] = 79358, + [SMALL_STATE(1556)] = 79412, + [SMALL_STATE(1557)] = 79464, + [SMALL_STATE(1558)] = 79518, + [SMALL_STATE(1559)] = 79570, + [SMALL_STATE(1560)] = 79624, + [SMALL_STATE(1561)] = 79684, + [SMALL_STATE(1562)] = 79764, + [SMALL_STATE(1563)] = 79844, + [SMALL_STATE(1564)] = 79946, + [SMALL_STATE(1565)] = 80001, + [SMALL_STATE(1566)] = 80060, + [SMALL_STATE(1567)] = 80111, + [SMALL_STATE(1568)] = 80166, + [SMALL_STATE(1569)] = 80221, + [SMALL_STATE(1570)] = 80276, + [SMALL_STATE(1571)] = 80327, + [SMALL_STATE(1572)] = 80378, + [SMALL_STATE(1573)] = 80429, + [SMALL_STATE(1574)] = 80484, + [SMALL_STATE(1575)] = 80539, + [SMALL_STATE(1576)] = 80590, + [SMALL_STATE(1577)] = 80645, + [SMALL_STATE(1578)] = 80704, + [SMALL_STATE(1579)] = 80759, + [SMALL_STATE(1580)] = 80810, + [SMALL_STATE(1581)] = 80861, + [SMALL_STATE(1582)] = 80912, + [SMALL_STATE(1583)] = 80963, + [SMALL_STATE(1584)] = 81014, + [SMALL_STATE(1585)] = 81065, + [SMALL_STATE(1586)] = 81116, + [SMALL_STATE(1587)] = 81175, + [SMALL_STATE(1588)] = 81230, + [SMALL_STATE(1589)] = 81281, + [SMALL_STATE(1590)] = 81338, + [SMALL_STATE(1591)] = 81389, + [SMALL_STATE(1592)] = 81444, + [SMALL_STATE(1593)] = 81507, + [SMALL_STATE(1594)] = 81558, + [SMALL_STATE(1595)] = 81609, + [SMALL_STATE(1596)] = 81660, + [SMALL_STATE(1597)] = 81715, + [SMALL_STATE(1598)] = 81770, + [SMALL_STATE(1599)] = 81821, + [SMALL_STATE(1600)] = 81876, + [SMALL_STATE(1601)] = 81933, + [SMALL_STATE(1602)] = 81984, + [SMALL_STATE(1603)] = 82035, + [SMALL_STATE(1604)] = 82090, + [SMALL_STATE(1605)] = 82141, + [SMALL_STATE(1606)] = 82200, + [SMALL_STATE(1607)] = 82263, + [SMALL_STATE(1608)] = 82314, + [SMALL_STATE(1609)] = 82365, + [SMALL_STATE(1610)] = 82416, + [SMALL_STATE(1611)] = 82467, + [SMALL_STATE(1612)] = 82518, + [SMALL_STATE(1613)] = 82569, + [SMALL_STATE(1614)] = 82620, + [SMALL_STATE(1615)] = 82679, + [SMALL_STATE(1616)] = 82730, + [SMALL_STATE(1617)] = 82781, + [SMALL_STATE(1618)] = 82832, + [SMALL_STATE(1619)] = 82883, + [SMALL_STATE(1620)] = 82938, + [SMALL_STATE(1621)] = 82993, + [SMALL_STATE(1622)] = 83044, + [SMALL_STATE(1623)] = 83095, + [SMALL_STATE(1624)] = 83154, + [SMALL_STATE(1625)] = 83204, + [SMALL_STATE(1626)] = 83256, + [SMALL_STATE(1627)] = 83308, + [SMALL_STATE(1628)] = 83358, + [SMALL_STATE(1629)] = 83408, + [SMALL_STATE(1630)] = 83458, + [SMALL_STATE(1631)] = 83548, + [SMALL_STATE(1632)] = 83598, + [SMALL_STATE(1633)] = 83648, + [SMALL_STATE(1634)] = 83700, + [SMALL_STATE(1635)] = 83750, + [SMALL_STATE(1636)] = 83800, + [SMALL_STATE(1637)] = 83850, + [SMALL_STATE(1638)] = 83904, + [SMALL_STATE(1639)] = 83954, + [SMALL_STATE(1640)] = 84004, + [SMALL_STATE(1641)] = 84054, + [SMALL_STATE(1642)] = 84104, + [SMALL_STATE(1643)] = 84154, + [SMALL_STATE(1644)] = 84204, + [SMALL_STATE(1645)] = 84258, + [SMALL_STATE(1646)] = 84312, + [SMALL_STATE(1647)] = 84364, + [SMALL_STATE(1648)] = 84416, + [SMALL_STATE(1649)] = 84466, + [SMALL_STATE(1650)] = 84520, + [SMALL_STATE(1651)] = 84570, + [SMALL_STATE(1652)] = 84620, + [SMALL_STATE(1653)] = 84674, + [SMALL_STATE(1654)] = 84726, + [SMALL_STATE(1655)] = 84778, + [SMALL_STATE(1656)] = 84830, + [SMALL_STATE(1657)] = 84882, + [SMALL_STATE(1658)] = 84932, + [SMALL_STATE(1659)] = 84982, + [SMALL_STATE(1660)] = 85032, + [SMALL_STATE(1661)] = 85084, + [SMALL_STATE(1662)] = 85134, + [SMALL_STATE(1663)] = 85188, + [SMALL_STATE(1664)] = 85238, + [SMALL_STATE(1665)] = 85290, + [SMALL_STATE(1666)] = 85340, + [SMALL_STATE(1667)] = 85390, + [SMALL_STATE(1668)] = 85440, + [SMALL_STATE(1669)] = 85492, + [SMALL_STATE(1670)] = 85544, + [SMALL_STATE(1671)] = 85596, + [SMALL_STATE(1672)] = 85648, + [SMALL_STATE(1673)] = 85698, + [SMALL_STATE(1674)] = 85748, + [SMALL_STATE(1675)] = 85798, + [SMALL_STATE(1676)] = 85850, + [SMALL_STATE(1677)] = 85902, + [SMALL_STATE(1678)] = 85952, + [SMALL_STATE(1679)] = 86004, + [SMALL_STATE(1680)] = 86053, + [SMALL_STATE(1681)] = 86102, + [SMALL_STATE(1682)] = 86195, + [SMALL_STATE(1683)] = 86244, + [SMALL_STATE(1684)] = 86337, + [SMALL_STATE(1685)] = 86430, + [SMALL_STATE(1686)] = 86479, + [SMALL_STATE(1687)] = 86528, + [SMALL_STATE(1688)] = 86621, + [SMALL_STATE(1689)] = 86670, + [SMALL_STATE(1690)] = 86719, + [SMALL_STATE(1691)] = 86812, + [SMALL_STATE(1692)] = 86861, + [SMALL_STATE(1693)] = 86954, + [SMALL_STATE(1694)] = 87047, + [SMALL_STATE(1695)] = 87096, + [SMALL_STATE(1696)] = 87145, + [SMALL_STATE(1697)] = 87194, + [SMALL_STATE(1698)] = 87287, + [SMALL_STATE(1699)] = 87336, + [SMALL_STATE(1700)] = 87385, + [SMALL_STATE(1701)] = 87434, + [SMALL_STATE(1702)] = 87483, + [SMALL_STATE(1703)] = 87532, + [SMALL_STATE(1704)] = 87625, + [SMALL_STATE(1705)] = 87718, + [SMALL_STATE(1706)] = 87767, + [SMALL_STATE(1707)] = 87860, + [SMALL_STATE(1708)] = 87953, + [SMALL_STATE(1709)] = 88002, + [SMALL_STATE(1710)] = 88051, + [SMALL_STATE(1711)] = 88100, + [SMALL_STATE(1712)] = 88149, + [SMALL_STATE(1713)] = 88198, + [SMALL_STATE(1714)] = 88291, + [SMALL_STATE(1715)] = 88384, + [SMALL_STATE(1716)] = 88477, + [SMALL_STATE(1717)] = 88570, + [SMALL_STATE(1718)] = 88619, + [SMALL_STATE(1719)] = 88712, + [SMALL_STATE(1720)] = 88805, + [SMALL_STATE(1721)] = 88854, + [SMALL_STATE(1722)] = 88903, + [SMALL_STATE(1723)] = 88952, + [SMALL_STATE(1724)] = 89001, + [SMALL_STATE(1725)] = 89050, + [SMALL_STATE(1726)] = 89099, + [SMALL_STATE(1727)] = 89148, + [SMALL_STATE(1728)] = 89197, + [SMALL_STATE(1729)] = 89245, + [SMALL_STATE(1730)] = 89337, + [SMALL_STATE(1731)] = 89385, + [SMALL_STATE(1732)] = 89451, + [SMALL_STATE(1733)] = 89499, + [SMALL_STATE(1734)] = 89569, + [SMALL_STATE(1735)] = 89617, + [SMALL_STATE(1736)] = 89685, + [SMALL_STATE(1737)] = 89733, + [SMALL_STATE(1738)] = 89780, + [SMALL_STATE(1739)] = 89827, + [SMALL_STATE(1740)] = 89874, + [SMALL_STATE(1741)] = 89921, + [SMALL_STATE(1742)] = 89968, + [SMALL_STATE(1743)] = 90015, + [SMALL_STATE(1744)] = 90062, + [SMALL_STATE(1745)] = 90109, + [SMALL_STATE(1746)] = 90156, + [SMALL_STATE(1747)] = 90237, + [SMALL_STATE(1748)] = 90284, + [SMALL_STATE(1749)] = 90331, + [SMALL_STATE(1750)] = 90378, + [SMALL_STATE(1751)] = 90459, + [SMALL_STATE(1752)] = 90506, + [SMALL_STATE(1753)] = 90553, + [SMALL_STATE(1754)] = 90600, + [SMALL_STATE(1755)] = 90647, + [SMALL_STATE(1756)] = 90694, + [SMALL_STATE(1757)] = 90741, + [SMALL_STATE(1758)] = 90788, + [SMALL_STATE(1759)] = 90835, + [SMALL_STATE(1760)] = 90882, + [SMALL_STATE(1761)] = 90929, + [SMALL_STATE(1762)] = 90976, + [SMALL_STATE(1763)] = 91057, + [SMALL_STATE(1764)] = 91104, + [SMALL_STATE(1765)] = 91151, + [SMALL_STATE(1766)] = 91198, + [SMALL_STATE(1767)] = 91245, + [SMALL_STATE(1768)] = 91292, + [SMALL_STATE(1769)] = 91339, + [SMALL_STATE(1770)] = 91386, + [SMALL_STATE(1771)] = 91433, + [SMALL_STATE(1772)] = 91480, + [SMALL_STATE(1773)] = 91527, + [SMALL_STATE(1774)] = 91574, + [SMALL_STATE(1775)] = 91621, + [SMALL_STATE(1776)] = 91668, + [SMALL_STATE(1777)] = 91715, + [SMALL_STATE(1778)] = 91762, + [SMALL_STATE(1779)] = 91809, + [SMALL_STATE(1780)] = 91856, + [SMALL_STATE(1781)] = 91903, + [SMALL_STATE(1782)] = 91950, + [SMALL_STATE(1783)] = 91997, + [SMALL_STATE(1784)] = 92044, + [SMALL_STATE(1785)] = 92091, + [SMALL_STATE(1786)] = 92138, + [SMALL_STATE(1787)] = 92185, + [SMALL_STATE(1788)] = 92232, + [SMALL_STATE(1789)] = 92279, + [SMALL_STATE(1790)] = 92326, + [SMALL_STATE(1791)] = 92373, + [SMALL_STATE(1792)] = 92420, + [SMALL_STATE(1793)] = 92467, + [SMALL_STATE(1794)] = 92514, + [SMALL_STATE(1795)] = 92561, + [SMALL_STATE(1796)] = 92608, + [SMALL_STATE(1797)] = 92655, + [SMALL_STATE(1798)] = 92702, + [SMALL_STATE(1799)] = 92749, + [SMALL_STATE(1800)] = 92796, + [SMALL_STATE(1801)] = 92843, + [SMALL_STATE(1802)] = 92890, + [SMALL_STATE(1803)] = 92937, + [SMALL_STATE(1804)] = 92984, + [SMALL_STATE(1805)] = 93031, + [SMALL_STATE(1806)] = 93078, + [SMALL_STATE(1807)] = 93125, + [SMALL_STATE(1808)] = 93172, + [SMALL_STATE(1809)] = 93219, + [SMALL_STATE(1810)] = 93266, + [SMALL_STATE(1811)] = 93313, + [SMALL_STATE(1812)] = 93360, + [SMALL_STATE(1813)] = 93407, + [SMALL_STATE(1814)] = 93488, + [SMALL_STATE(1815)] = 93535, + [SMALL_STATE(1816)] = 93582, + [SMALL_STATE(1817)] = 93636, + [SMALL_STATE(1818)] = 93722, + [SMALL_STATE(1819)] = 93808, + [SMALL_STATE(1820)] = 93894, + [SMALL_STATE(1821)] = 93980, + [SMALL_STATE(1822)] = 94066, + [SMALL_STATE(1823)] = 94152, + [SMALL_STATE(1824)] = 94238, + [SMALL_STATE(1825)] = 94318, + [SMALL_STATE(1826)] = 94401, + [SMALL_STATE(1827)] = 94468, + [SMALL_STATE(1828)] = 94549, + [SMALL_STATE(1829)] = 94632, + [SMALL_STATE(1830)] = 94699, + [SMALL_STATE(1831)] = 94748, + [SMALL_STATE(1832)] = 94829, + [SMALL_STATE(1833)] = 94912, + [SMALL_STATE(1834)] = 94992, + [SMALL_STATE(1835)] = 95036, + [SMALL_STATE(1836)] = 95080, + [SMALL_STATE(1837)] = 95124, + [SMALL_STATE(1838)] = 95168, + [SMALL_STATE(1839)] = 95248, + [SMALL_STATE(1840)] = 95292, + [SMALL_STATE(1841)] = 95336, + [SMALL_STATE(1842)] = 95380, + [SMALL_STATE(1843)] = 95424, + [SMALL_STATE(1844)] = 95468, + [SMALL_STATE(1845)] = 95512, + [SMALL_STATE(1846)] = 95556, + [SMALL_STATE(1847)] = 95600, + [SMALL_STATE(1848)] = 95666, + [SMALL_STATE(1849)] = 95746, + [SMALL_STATE(1850)] = 95826, + [SMALL_STATE(1851)] = 95906, + [SMALL_STATE(1852)] = 95986, + [SMALL_STATE(1853)] = 96066, + [SMALL_STATE(1854)] = 96114, + [SMALL_STATE(1855)] = 96158, + [SMALL_STATE(1856)] = 96234, + [SMALL_STATE(1857)] = 96314, + [SMALL_STATE(1858)] = 96394, + [SMALL_STATE(1859)] = 96438, + [SMALL_STATE(1860)] = 96518, + [SMALL_STATE(1861)] = 96598, + [SMALL_STATE(1862)] = 96678, + [SMALL_STATE(1863)] = 96722, + [SMALL_STATE(1864)] = 96766, + [SMALL_STATE(1865)] = 96832, + [SMALL_STATE(1866)] = 96912, + [SMALL_STATE(1867)] = 96978, + [SMALL_STATE(1868)] = 97058, + [SMALL_STATE(1869)] = 97138, + [SMALL_STATE(1870)] = 97218, + [SMALL_STATE(1871)] = 97298, + [SMALL_STATE(1872)] = 97378, + [SMALL_STATE(1873)] = 97458, + [SMALL_STATE(1874)] = 97534, + [SMALL_STATE(1875)] = 97614, + [SMALL_STATE(1876)] = 97694, + [SMALL_STATE(1877)] = 97774, + [SMALL_STATE(1878)] = 97854, + [SMALL_STATE(1879)] = 97934, + [SMALL_STATE(1880)] = 98014, + [SMALL_STATE(1881)] = 98094, + [SMALL_STATE(1882)] = 98174, + [SMALL_STATE(1883)] = 98254, + [SMALL_STATE(1884)] = 98334, + [SMALL_STATE(1885)] = 98414, + [SMALL_STATE(1886)] = 98494, + [SMALL_STATE(1887)] = 98574, + [SMALL_STATE(1888)] = 98654, + [SMALL_STATE(1889)] = 98734, + [SMALL_STATE(1890)] = 98814, + [SMALL_STATE(1891)] = 98894, + [SMALL_STATE(1892)] = 98974, + [SMALL_STATE(1893)] = 99054, + [SMALL_STATE(1894)] = 99134, + [SMALL_STATE(1895)] = 99214, + [SMALL_STATE(1896)] = 99294, + [SMALL_STATE(1897)] = 99374, + [SMALL_STATE(1898)] = 99418, + [SMALL_STATE(1899)] = 99498, + [SMALL_STATE(1900)] = 99578, + [SMALL_STATE(1901)] = 99658, + [SMALL_STATE(1902)] = 99738, + [SMALL_STATE(1903)] = 99818, + [SMALL_STATE(1904)] = 99898, + [SMALL_STATE(1905)] = 99978, + [SMALL_STATE(1906)] = 100058, + [SMALL_STATE(1907)] = 100135, + [SMALL_STATE(1908)] = 100212, + [SMALL_STATE(1909)] = 100289, + [SMALL_STATE(1910)] = 100350, + [SMALL_STATE(1911)] = 100427, + [SMALL_STATE(1912)] = 100470, + [SMALL_STATE(1913)] = 100533, + [SMALL_STATE(1914)] = 100610, + [SMALL_STATE(1915)] = 100687, + [SMALL_STATE(1916)] = 100764, + [SMALL_STATE(1917)] = 100807, + [SMALL_STATE(1918)] = 100870, + [SMALL_STATE(1919)] = 100933, + [SMALL_STATE(1920)] = 101008, + [SMALL_STATE(1921)] = 101051, + [SMALL_STATE(1922)] = 101128, + [SMALL_STATE(1923)] = 101205, + [SMALL_STATE(1924)] = 101268, + [SMALL_STATE(1925)] = 101345, + [SMALL_STATE(1926)] = 101422, + [SMALL_STATE(1927)] = 101499, + [SMALL_STATE(1928)] = 101576, + [SMALL_STATE(1929)] = 101653, + [SMALL_STATE(1930)] = 101730, + [SMALL_STATE(1931)] = 101807, + [SMALL_STATE(1932)] = 101884, + [SMALL_STATE(1933)] = 101961, + [SMALL_STATE(1934)] = 102038, + [SMALL_STATE(1935)] = 102115, + [SMALL_STATE(1936)] = 102192, + [SMALL_STATE(1937)] = 102244, + [SMALL_STATE(1938)] = 102318, + [SMALL_STATE(1939)] = 102360, + [SMALL_STATE(1940)] = 102434, + [SMALL_STATE(1941)] = 102504, + [SMALL_STATE(1942)] = 102578, + [SMALL_STATE(1943)] = 102648, + [SMALL_STATE(1944)] = 102722, + [SMALL_STATE(1945)] = 102796, + [SMALL_STATE(1946)] = 102870, + [SMALL_STATE(1947)] = 102940, + [SMALL_STATE(1948)] = 103000, + [SMALL_STATE(1949)] = 103074, + [SMALL_STATE(1950)] = 103148, + [SMALL_STATE(1951)] = 103218, + [SMALL_STATE(1952)] = 103288, + [SMALL_STATE(1953)] = 103355, + [SMALL_STATE(1954)] = 103426, + [SMALL_STATE(1955)] = 103471, + [SMALL_STATE(1956)] = 103512, + [SMALL_STATE(1957)] = 103579, + [SMALL_STATE(1958)] = 103624, + [SMALL_STATE(1959)] = 103669, + [SMALL_STATE(1960)] = 103714, + [SMALL_STATE(1961)] = 103781, + [SMALL_STATE(1962)] = 103826, + [SMALL_STATE(1963)] = 103897, + [SMALL_STATE(1964)] = 103942, + [SMALL_STATE(1965)] = 103987, + [SMALL_STATE(1966)] = 104032, + [SMALL_STATE(1967)] = 104073, + [SMALL_STATE(1968)] = 104142, + [SMALL_STATE(1969)] = 104211, + [SMALL_STATE(1970)] = 104256, + [SMALL_STATE(1971)] = 104323, + [SMALL_STATE(1972)] = 104364, + [SMALL_STATE(1973)] = 104433, + [SMALL_STATE(1974)] = 104500, + [SMALL_STATE(1975)] = 104545, + [SMALL_STATE(1976)] = 104616, + [SMALL_STATE(1977)] = 104685, + [SMALL_STATE(1978)] = 104730, + [SMALL_STATE(1979)] = 104793, + [SMALL_STATE(1980)] = 104862, + [SMALL_STATE(1981)] = 104903, + [SMALL_STATE(1982)] = 104962, + [SMALL_STATE(1983)] = 105007, + [SMALL_STATE(1984)] = 105052, + [SMALL_STATE(1985)] = 105097, + [SMALL_STATE(1986)] = 105137, + [SMALL_STATE(1987)] = 105177, + [SMALL_STATE(1988)] = 105217, + [SMALL_STATE(1989)] = 105257, + [SMALL_STATE(1990)] = 105325, + [SMALL_STATE(1991)] = 105365, + [SMALL_STATE(1992)] = 105405, + [SMALL_STATE(1993)] = 105445, + [SMALL_STATE(1994)] = 105513, + [SMALL_STATE(1995)] = 105553, + [SMALL_STATE(1996)] = 105592, + [SMALL_STATE(1997)] = 105631, + [SMALL_STATE(1998)] = 105670, + [SMALL_STATE(1999)] = 105709, + [SMALL_STATE(2000)] = 105748, + [SMALL_STATE(2001)] = 105787, + [SMALL_STATE(2002)] = 105826, + [SMALL_STATE(2003)] = 105865, + [SMALL_STATE(2004)] = 105910, + [SMALL_STATE(2005)] = 105949, + [SMALL_STATE(2006)] = 106012, + [SMALL_STATE(2007)] = 106051, + [SMALL_STATE(2008)] = 106090, + [SMALL_STATE(2009)] = 106155, + [SMALL_STATE(2010)] = 106218, + [SMALL_STATE(2011)] = 106283, + [SMALL_STATE(2012)] = 106320, + [SMALL_STATE(2013)] = 106359, + [SMALL_STATE(2014)] = 106398, + [SMALL_STATE(2015)] = 106461, + [SMALL_STATE(2016)] = 106524, + [SMALL_STATE(2017)] = 106581, + [SMALL_STATE(2018)] = 106646, + [SMALL_STATE(2019)] = 106711, + [SMALL_STATE(2020)] = 106776, + [SMALL_STATE(2021)] = 106815, + [SMALL_STATE(2022)] = 106880, + [SMALL_STATE(2023)] = 106945, + [SMALL_STATE(2024)] = 107008, + [SMALL_STATE(2025)] = 107073, + [SMALL_STATE(2026)] = 107112, + [SMALL_STATE(2027)] = 107151, + [SMALL_STATE(2028)] = 107190, + [SMALL_STATE(2029)] = 107252, + [SMALL_STATE(2030)] = 107290, + [SMALL_STATE(2031)] = 107328, + [SMALL_STATE(2032)] = 107390, + [SMALL_STATE(2033)] = 107428, + [SMALL_STATE(2034)] = 107490, + [SMALL_STATE(2035)] = 107528, + [SMALL_STATE(2036)] = 107568, + [SMALL_STATE(2037)] = 107630, + [SMALL_STATE(2038)] = 107680, + [SMALL_STATE(2039)] = 107718, + [SMALL_STATE(2040)] = 107780, + [SMALL_STATE(2041)] = 107818, + [SMALL_STATE(2042)] = 107880, + [SMALL_STATE(2043)] = 107942, + [SMALL_STATE(2044)] = 107980, + [SMALL_STATE(2045)] = 108018, + [SMALL_STATE(2046)] = 108056, + [SMALL_STATE(2047)] = 108094, + [SMALL_STATE(2048)] = 108132, + [SMALL_STATE(2049)] = 108194, + [SMALL_STATE(2050)] = 108256, + [SMALL_STATE(2051)] = 108318, + [SMALL_STATE(2052)] = 108356, + [SMALL_STATE(2053)] = 108418, + [SMALL_STATE(2054)] = 108456, + [SMALL_STATE(2055)] = 108518, + [SMALL_STATE(2056)] = 108556, + [SMALL_STATE(2057)] = 108594, + [SMALL_STATE(2058)] = 108656, + [SMALL_STATE(2059)] = 108718, + [SMALL_STATE(2060)] = 108780, + [SMALL_STATE(2061)] = 108842, + [SMALL_STATE(2062)] = 108880, + [SMALL_STATE(2063)] = 108918, + [SMALL_STATE(2064)] = 108956, + [SMALL_STATE(2065)] = 109010, + [SMALL_STATE(2066)] = 109072, + [SMALL_STATE(2067)] = 109110, + [SMALL_STATE(2068)] = 109172, + [SMALL_STATE(2069)] = 109222, + [SMALL_STATE(2070)] = 109260, + [SMALL_STATE(2071)] = 109298, + [SMALL_STATE(2072)] = 109336, + [SMALL_STATE(2073)] = 109374, + [SMALL_STATE(2074)] = 109416, + [SMALL_STATE(2075)] = 109478, + [SMALL_STATE(2076)] = 109540, + [SMALL_STATE(2077)] = 109578, + [SMALL_STATE(2078)] = 109616, + [SMALL_STATE(2079)] = 109666, + [SMALL_STATE(2080)] = 109728, + [SMALL_STATE(2081)] = 109778, + [SMALL_STATE(2082)] = 109837, + [SMALL_STATE(2083)] = 109896, + [SMALL_STATE(2084)] = 109955, + [SMALL_STATE(2085)] = 110014, + [SMALL_STATE(2086)] = 110073, + [SMALL_STATE(2087)] = 110132, + [SMALL_STATE(2088)] = 110191, + [SMALL_STATE(2089)] = 110250, + [SMALL_STATE(2090)] = 110309, + [SMALL_STATE(2091)] = 110348, + [SMALL_STATE(2092)] = 110407, + [SMALL_STATE(2093)] = 110466, + [SMALL_STATE(2094)] = 110525, + [SMALL_STATE(2095)] = 110584, + [SMALL_STATE(2096)] = 110623, + [SMALL_STATE(2097)] = 110682, + [SMALL_STATE(2098)] = 110741, + [SMALL_STATE(2099)] = 110800, + [SMALL_STATE(2100)] = 110859, + [SMALL_STATE(2101)] = 110918, + [SMALL_STATE(2102)] = 110977, + [SMALL_STATE(2103)] = 111036, + [SMALL_STATE(2104)] = 111095, + [SMALL_STATE(2105)] = 111154, + [SMALL_STATE(2106)] = 111213, + [SMALL_STATE(2107)] = 111272, + [SMALL_STATE(2108)] = 111331, + [SMALL_STATE(2109)] = 111390, + [SMALL_STATE(2110)] = 111449, + [SMALL_STATE(2111)] = 111488, + [SMALL_STATE(2112)] = 111547, + [SMALL_STATE(2113)] = 111606, + [SMALL_STATE(2114)] = 111665, + [SMALL_STATE(2115)] = 111724, + [SMALL_STATE(2116)] = 111765, + [SMALL_STATE(2117)] = 111824, + [SMALL_STATE(2118)] = 111883, + [SMALL_STATE(2119)] = 111942, + [SMALL_STATE(2120)] = 111995, + [SMALL_STATE(2121)] = 112054, + [SMALL_STATE(2122)] = 112113, + [SMALL_STATE(2123)] = 112172, + [SMALL_STATE(2124)] = 112225, + [SMALL_STATE(2125)] = 112284, + [SMALL_STATE(2126)] = 112319, + [SMALL_STATE(2127)] = 112378, + [SMALL_STATE(2128)] = 112437, + [SMALL_STATE(2129)] = 112481, + [SMALL_STATE(2130)] = 112515, + [SMALL_STATE(2131)] = 112549, + [SMALL_STATE(2132)] = 112605, + [SMALL_STATE(2133)] = 112639, + [SMALL_STATE(2134)] = 112673, + [SMALL_STATE(2135)] = 112707, + [SMALL_STATE(2136)] = 112741, + [SMALL_STATE(2137)] = 112775, + [SMALL_STATE(2138)] = 112821, + [SMALL_STATE(2139)] = 112867, + [SMALL_STATE(2140)] = 112901, + [SMALL_STATE(2141)] = 112935, + [SMALL_STATE(2142)] = 112989, + [SMALL_STATE(2143)] = 113043, + [SMALL_STATE(2144)] = 113077, + [SMALL_STATE(2145)] = 113117, + [SMALL_STATE(2146)] = 113151, + [SMALL_STATE(2147)] = 113185, + [SMALL_STATE(2148)] = 113219, + [SMALL_STATE(2149)] = 113253, + [SMALL_STATE(2150)] = 113287, + [SMALL_STATE(2151)] = 113321, + [SMALL_STATE(2152)] = 113355, + [SMALL_STATE(2153)] = 113389, + [SMALL_STATE(2154)] = 113445, + [SMALL_STATE(2155)] = 113493, + [SMALL_STATE(2156)] = 113527, + [SMALL_STATE(2157)] = 113561, + [SMALL_STATE(2158)] = 113595, + [SMALL_STATE(2159)] = 113631, + [SMALL_STATE(2160)] = 113677, + [SMALL_STATE(2161)] = 113723, + [SMALL_STATE(2162)] = 113770, + [SMALL_STATE(2163)] = 113809, + [SMALL_STATE(2164)] = 113850, + [SMALL_STATE(2165)] = 113891, + [SMALL_STATE(2166)] = 113928, + [SMALL_STATE(2167)] = 113981, + [SMALL_STATE(2168)] = 114018, + [SMALL_STATE(2169)] = 114057, + [SMALL_STATE(2170)] = 114104, + [SMALL_STATE(2171)] = 114157, + [SMALL_STATE(2172)] = 114198, + [SMALL_STATE(2173)] = 114237, + [SMALL_STATE(2174)] = 114276, + [SMALL_STATE(2175)] = 114314, + [SMALL_STATE(2176)] = 114364, + [SMALL_STATE(2177)] = 114410, + [SMALL_STATE(2178)] = 114454, + [SMALL_STATE(2179)] = 114490, + [SMALL_STATE(2180)] = 114534, + [SMALL_STATE(2181)] = 114568, + [SMALL_STATE(2182)] = 114612, + [SMALL_STATE(2183)] = 114656, + [SMALL_STATE(2184)] = 114700, + [SMALL_STATE(2185)] = 114744, + [SMALL_STATE(2186)] = 114786, + [SMALL_STATE(2187)] = 114828, + [SMALL_STATE(2188)] = 114870, + [SMALL_STATE(2189)] = 114910, + [SMALL_STATE(2190)] = 114954, + [SMALL_STATE(2191)] = 114988, + [SMALL_STATE(2192)] = 115022, + [SMALL_STATE(2193)] = 115066, + [SMALL_STATE(2194)] = 115110, + [SMALL_STATE(2195)] = 115144, + [SMALL_STATE(2196)] = 115188, + [SMALL_STATE(2197)] = 115226, + [SMALL_STATE(2198)] = 115270, + [SMALL_STATE(2199)] = 115314, + [SMALL_STATE(2200)] = 115358, + [SMALL_STATE(2201)] = 115402, + [SMALL_STATE(2202)] = 115452, + [SMALL_STATE(2203)] = 115494, + [SMALL_STATE(2204)] = 115532, + [SMALL_STATE(2205)] = 115578, + [SMALL_STATE(2206)] = 115622, + [SMALL_STATE(2207)] = 115666, + [SMALL_STATE(2208)] = 115716, + [SMALL_STATE(2209)] = 115760, + [SMALL_STATE(2210)] = 115804, + [SMALL_STATE(2211)] = 115848, + [SMALL_STATE(2212)] = 115892, + [SMALL_STATE(2213)] = 115933, + [SMALL_STATE(2214)] = 115964, + [SMALL_STATE(2215)] = 115995, + [SMALL_STATE(2216)] = 116036, + [SMALL_STATE(2217)] = 116079, + [SMALL_STATE(2218)] = 116120, + [SMALL_STATE(2219)] = 116161, + [SMALL_STATE(2220)] = 116202, + [SMALL_STATE(2221)] = 116247, + [SMALL_STATE(2222)] = 116288, + [SMALL_STATE(2223)] = 116331, + [SMALL_STATE(2224)] = 116378, + [SMALL_STATE(2225)] = 116425, + [SMALL_STATE(2226)] = 116464, + [SMALL_STATE(2227)] = 116503, + [SMALL_STATE(2228)] = 116534, + [SMALL_STATE(2229)] = 116565, + [SMALL_STATE(2230)] = 116604, + [SMALL_STATE(2231)] = 116645, + [SMALL_STATE(2232)] = 116684, + [SMALL_STATE(2233)] = 116727, + [SMALL_STATE(2234)] = 116772, + [SMALL_STATE(2235)] = 116815, + [SMALL_STATE(2236)] = 116856, + [SMALL_STATE(2237)] = 116897, + [SMALL_STATE(2238)] = 116938, + [SMALL_STATE(2239)] = 116979, + [SMALL_STATE(2240)] = 117012, + [SMALL_STATE(2241)] = 117053, + [SMALL_STATE(2242)] = 117094, + [SMALL_STATE(2243)] = 117135, + [SMALL_STATE(2244)] = 117176, + [SMALL_STATE(2245)] = 117221, + [SMALL_STATE(2246)] = 117262, + [SMALL_STATE(2247)] = 117303, + [SMALL_STATE(2248)] = 117344, + [SMALL_STATE(2249)] = 117389, + [SMALL_STATE(2250)] = 117422, + [SMALL_STATE(2251)] = 117463, + [SMALL_STATE(2252)] = 117504, + [SMALL_STATE(2253)] = 117545, + [SMALL_STATE(2254)] = 117586, + [SMALL_STATE(2255)] = 117627, + [SMALL_STATE(2256)] = 117668, + [SMALL_STATE(2257)] = 117709, + [SMALL_STATE(2258)] = 117750, + [SMALL_STATE(2259)] = 117791, + [SMALL_STATE(2260)] = 117838, + [SMALL_STATE(2261)] = 117881, + [SMALL_STATE(2262)] = 117912, + [SMALL_STATE(2263)] = 117953, + [SMALL_STATE(2264)] = 117994, + [SMALL_STATE(2265)] = 118035, + [SMALL_STATE(2266)] = 118076, + [SMALL_STATE(2267)] = 118117, + [SMALL_STATE(2268)] = 118158, + [SMALL_STATE(2269)] = 118199, + [SMALL_STATE(2270)] = 118240, + [SMALL_STATE(2271)] = 118281, + [SMALL_STATE(2272)] = 118322, + [SMALL_STATE(2273)] = 118363, + [SMALL_STATE(2274)] = 118404, + [SMALL_STATE(2275)] = 118451, + [SMALL_STATE(2276)] = 118492, + [SMALL_STATE(2277)] = 118533, + [SMALL_STATE(2278)] = 118574, + [SMALL_STATE(2279)] = 118615, + [SMALL_STATE(2280)] = 118656, + [SMALL_STATE(2281)] = 118697, + [SMALL_STATE(2282)] = 118742, + [SMALL_STATE(2283)] = 118783, + [SMALL_STATE(2284)] = 118824, + [SMALL_STATE(2285)] = 118869, + [SMALL_STATE(2286)] = 118900, + [SMALL_STATE(2287)] = 118931, + [SMALL_STATE(2288)] = 118976, + [SMALL_STATE(2289)] = 119017, + [SMALL_STATE(2290)] = 119049, + [SMALL_STATE(2291)] = 119085, + [SMALL_STATE(2292)] = 119127, + [SMALL_STATE(2293)] = 119171, + [SMALL_STATE(2294)] = 119205, + [SMALL_STATE(2295)] = 119241, + [SMALL_STATE(2296)] = 119277, + [SMALL_STATE(2297)] = 119313, + [SMALL_STATE(2298)] = 119351, + [SMALL_STATE(2299)] = 119389, + [SMALL_STATE(2300)] = 119425, + [SMALL_STATE(2301)] = 119461, + [SMALL_STATE(2302)] = 119505, + [SMALL_STATE(2303)] = 119547, + [SMALL_STATE(2304)] = 119585, + [SMALL_STATE(2305)] = 119623, + [SMALL_STATE(2306)] = 119661, + [SMALL_STATE(2307)] = 119693, + [SMALL_STATE(2308)] = 119725, + [SMALL_STATE(2309)] = 119769, + [SMALL_STATE(2310)] = 119811, + [SMALL_STATE(2311)] = 119855, + [SMALL_STATE(2312)] = 119899, + [SMALL_STATE(2313)] = 119931, + [SMALL_STATE(2314)] = 119965, + [SMALL_STATE(2315)] = 120001, + [SMALL_STATE(2316)] = 120045, + [SMALL_STATE(2317)] = 120079, + [SMALL_STATE(2318)] = 120117, + [SMALL_STATE(2319)] = 120155, + [SMALL_STATE(2320)] = 120189, + [SMALL_STATE(2321)] = 120225, + [SMALL_STATE(2322)] = 120261, + [SMALL_STATE(2323)] = 120295, + [SMALL_STATE(2324)] = 120333, + [SMALL_STATE(2325)] = 120371, + [SMALL_STATE(2326)] = 120403, + [SMALL_STATE(2327)] = 120441, + [SMALL_STATE(2328)] = 120477, + [SMALL_STATE(2329)] = 120515, + [SMALL_STATE(2330)] = 120553, + [SMALL_STATE(2331)] = 120591, + [SMALL_STATE(2332)] = 120629, + [SMALL_STATE(2333)] = 120667, + [SMALL_STATE(2334)] = 120703, + [SMALL_STATE(2335)] = 120741, + [SMALL_STATE(2336)] = 120783, + [SMALL_STATE(2337)] = 120819, + [SMALL_STATE(2338)] = 120863, + [SMALL_STATE(2339)] = 120901, + [SMALL_STATE(2340)] = 120939, + [SMALL_STATE(2341)] = 120975, + [SMALL_STATE(2342)] = 121013, + [SMALL_STATE(2343)] = 121051, + [SMALL_STATE(2344)] = 121087, + [SMALL_STATE(2345)] = 121119, + [SMALL_STATE(2346)] = 121163, + [SMALL_STATE(2347)] = 121195, + [SMALL_STATE(2348)] = 121225, + [SMALL_STATE(2349)] = 121259, + [SMALL_STATE(2350)] = 121303, + [SMALL_STATE(2351)] = 121333, + [SMALL_STATE(2352)] = 121369, + [SMALL_STATE(2353)] = 121403, + [SMALL_STATE(2354)] = 121447, + [SMALL_STATE(2355)] = 121483, + [SMALL_STATE(2356)] = 121515, + [SMALL_STATE(2357)] = 121559, + [SMALL_STATE(2358)] = 121595, + [SMALL_STATE(2359)] = 121639, + [SMALL_STATE(2360)] = 121669, + [SMALL_STATE(2361)] = 121708, + [SMALL_STATE(2362)] = 121737, + [SMALL_STATE(2363)] = 121768, + [SMALL_STATE(2364)] = 121799, + [SMALL_STATE(2365)] = 121830, + [SMALL_STATE(2366)] = 121861, + [SMALL_STATE(2367)] = 121892, + [SMALL_STATE(2368)] = 121923, + [SMALL_STATE(2369)] = 121954, + [SMALL_STATE(2370)] = 121985, + [SMALL_STATE(2371)] = 122016, + [SMALL_STATE(2372)] = 122047, + [SMALL_STATE(2373)] = 122080, + [SMALL_STATE(2374)] = 122111, + [SMALL_STATE(2375)] = 122144, + [SMALL_STATE(2376)] = 122175, + [SMALL_STATE(2377)] = 122206, + [SMALL_STATE(2378)] = 122237, + [SMALL_STATE(2379)] = 122268, + [SMALL_STATE(2380)] = 122301, + [SMALL_STATE(2381)] = 122332, + [SMALL_STATE(2382)] = 122363, + [SMALL_STATE(2383)] = 122394, + [SMALL_STATE(2384)] = 122425, + [SMALL_STATE(2385)] = 122462, + [SMALL_STATE(2386)] = 122499, + [SMALL_STATE(2387)] = 122530, + [SMALL_STATE(2388)] = 122561, + [SMALL_STATE(2389)] = 122592, + [SMALL_STATE(2390)] = 122623, + [SMALL_STATE(2391)] = 122654, + [SMALL_STATE(2392)] = 122685, + [SMALL_STATE(2393)] = 122722, + [SMALL_STATE(2394)] = 122761, + [SMALL_STATE(2395)] = 122792, + [SMALL_STATE(2396)] = 122823, + [SMALL_STATE(2397)] = 122854, + [SMALL_STATE(2398)] = 122885, + [SMALL_STATE(2399)] = 122920, + [SMALL_STATE(2400)] = 122959, + [SMALL_STATE(2401)] = 122990, + [SMALL_STATE(2402)] = 123031, + [SMALL_STATE(2403)] = 123062, + [SMALL_STATE(2404)] = 123093, + [SMALL_STATE(2405)] = 123124, + [SMALL_STATE(2406)] = 123155, + [SMALL_STATE(2407)] = 123186, + [SMALL_STATE(2408)] = 123227, + [SMALL_STATE(2409)] = 123268, + [SMALL_STATE(2410)] = 123299, + [SMALL_STATE(2411)] = 123330, + [SMALL_STATE(2412)] = 123361, + [SMALL_STATE(2413)] = 123392, + [SMALL_STATE(2414)] = 123433, + [SMALL_STATE(2415)] = 123472, + [SMALL_STATE(2416)] = 123503, + [SMALL_STATE(2417)] = 123534, + [SMALL_STATE(2418)] = 123573, + [SMALL_STATE(2419)] = 123612, + [SMALL_STATE(2420)] = 123643, + [SMALL_STATE(2421)] = 123674, + [SMALL_STATE(2422)] = 123713, + [SMALL_STATE(2423)] = 123746, + [SMALL_STATE(2424)] = 123779, + [SMALL_STATE(2425)] = 123820, + [SMALL_STATE(2426)] = 123851, + [SMALL_STATE(2427)] = 123882, + [SMALL_STATE(2428)] = 123913, + [SMALL_STATE(2429)] = 123944, + [SMALL_STATE(2430)] = 123975, + [SMALL_STATE(2431)] = 124006, + [SMALL_STATE(2432)] = 124037, + [SMALL_STATE(2433)] = 124068, + [SMALL_STATE(2434)] = 124099, + [SMALL_STATE(2435)] = 124130, + [SMALL_STATE(2436)] = 124161, + [SMALL_STATE(2437)] = 124200, + [SMALL_STATE(2438)] = 124239, + [SMALL_STATE(2439)] = 124270, + [SMALL_STATE(2440)] = 124301, + [SMALL_STATE(2441)] = 124332, + [SMALL_STATE(2442)] = 124363, + [SMALL_STATE(2443)] = 124394, + [SMALL_STATE(2444)] = 124425, + [SMALL_STATE(2445)] = 124466, + [SMALL_STATE(2446)] = 124507, + [SMALL_STATE(2447)] = 124542, + [SMALL_STATE(2448)] = 124573, + [SMALL_STATE(2449)] = 124604, + [SMALL_STATE(2450)] = 124645, + [SMALL_STATE(2451)] = 124676, + [SMALL_STATE(2452)] = 124717, + [SMALL_STATE(2453)] = 124758, + [SMALL_STATE(2454)] = 124789, + [SMALL_STATE(2455)] = 124820, + [SMALL_STATE(2456)] = 124849, + [SMALL_STATE(2457)] = 124880, + [SMALL_STATE(2458)] = 124911, + [SMALL_STATE(2459)] = 124942, + [SMALL_STATE(2460)] = 124977, + [SMALL_STATE(2461)] = 125016, + [SMALL_STATE(2462)] = 125047, + [SMALL_STATE(2463)] = 125088, + [SMALL_STATE(2464)] = 125119, + [SMALL_STATE(2465)] = 125160, + [SMALL_STATE(2466)] = 125201, + [SMALL_STATE(2467)] = 125242, + [SMALL_STATE(2468)] = 125273, + [SMALL_STATE(2469)] = 125303, + [SMALL_STATE(2470)] = 125341, + [SMALL_STATE(2471)] = 125379, + [SMALL_STATE(2472)] = 125417, + [SMALL_STATE(2473)] = 125453, + [SMALL_STATE(2474)] = 125483, + [SMALL_STATE(2475)] = 125511, + [SMALL_STATE(2476)] = 125539, + [SMALL_STATE(2477)] = 125577, + [SMALL_STATE(2478)] = 125613, + [SMALL_STATE(2479)] = 125641, + [SMALL_STATE(2480)] = 125679, + [SMALL_STATE(2481)] = 125709, + [SMALL_STATE(2482)] = 125737, + [SMALL_STATE(2483)] = 125775, + [SMALL_STATE(2484)] = 125805, + [SMALL_STATE(2485)] = 125843, + [SMALL_STATE(2486)] = 125877, + [SMALL_STATE(2487)] = 125911, + [SMALL_STATE(2488)] = 125939, + [SMALL_STATE(2489)] = 125975, + [SMALL_STATE(2490)] = 126013, + [SMALL_STATE(2491)] = 126049, + [SMALL_STATE(2492)] = 126079, + [SMALL_STATE(2493)] = 126117, + [SMALL_STATE(2494)] = 126145, + [SMALL_STATE(2495)] = 126183, + [SMALL_STATE(2496)] = 126211, + [SMALL_STATE(2497)] = 126249, + [SMALL_STATE(2498)] = 126285, + [SMALL_STATE(2499)] = 126321, + [SMALL_STATE(2500)] = 126351, + [SMALL_STATE(2501)] = 126379, + [SMALL_STATE(2502)] = 126407, + [SMALL_STATE(2503)] = 126441, + [SMALL_STATE(2504)] = 126479, + [SMALL_STATE(2505)] = 126513, + [SMALL_STATE(2506)] = 126549, + [SMALL_STATE(2507)] = 126579, + [SMALL_STATE(2508)] = 126617, + [SMALL_STATE(2509)] = 126647, + [SMALL_STATE(2510)] = 126685, + [SMALL_STATE(2511)] = 126723, + [SMALL_STATE(2512)] = 126753, + [SMALL_STATE(2513)] = 126789, + [SMALL_STATE(2514)] = 126819, + [SMALL_STATE(2515)] = 126849, + [SMALL_STATE(2516)] = 126879, + [SMALL_STATE(2517)] = 126915, + [SMALL_STATE(2518)] = 126953, + [SMALL_STATE(2519)] = 126983, + [SMALL_STATE(2520)] = 127013, + [SMALL_STATE(2521)] = 127043, + [SMALL_STATE(2522)] = 127071, + [SMALL_STATE(2523)] = 127107, + [SMALL_STATE(2524)] = 127137, + [SMALL_STATE(2525)] = 127165, + [SMALL_STATE(2526)] = 127195, + [SMALL_STATE(2527)] = 127233, + [SMALL_STATE(2528)] = 127261, + [SMALL_STATE(2529)] = 127299, + [SMALL_STATE(2530)] = 127337, + [SMALL_STATE(2531)] = 127375, + [SMALL_STATE(2532)] = 127403, + [SMALL_STATE(2533)] = 127439, + [SMALL_STATE(2534)] = 127477, + [SMALL_STATE(2535)] = 127505, + [SMALL_STATE(2536)] = 127541, + [SMALL_STATE(2537)] = 127569, + [SMALL_STATE(2538)] = 127607, + [SMALL_STATE(2539)] = 127643, + [SMALL_STATE(2540)] = 127673, + [SMALL_STATE(2541)] = 127707, + [SMALL_STATE(2542)] = 127737, + [SMALL_STATE(2543)] = 127767, + [SMALL_STATE(2544)] = 127805, + [SMALL_STATE(2545)] = 127833, + [SMALL_STATE(2546)] = 127865, + [SMALL_STATE(2547)] = 127897, + [SMALL_STATE(2548)] = 127927, + [SMALL_STATE(2549)] = 127963, + [SMALL_STATE(2550)] = 128001, + [SMALL_STATE(2551)] = 128029, + [SMALL_STATE(2552)] = 128057, + [SMALL_STATE(2553)] = 128087, + [SMALL_STATE(2554)] = 128117, + [SMALL_STATE(2555)] = 128147, + [SMALL_STATE(2556)] = 128175, + [SMALL_STATE(2557)] = 128213, + [SMALL_STATE(2558)] = 128248, + [SMALL_STATE(2559)] = 128279, + [SMALL_STATE(2560)] = 128308, + [SMALL_STATE(2561)] = 128343, + [SMALL_STATE(2562)] = 128378, + [SMALL_STATE(2563)] = 128409, + [SMALL_STATE(2564)] = 128444, + [SMALL_STATE(2565)] = 128479, + [SMALL_STATE(2566)] = 128510, + [SMALL_STATE(2567)] = 128545, + [SMALL_STATE(2568)] = 128580, + [SMALL_STATE(2569)] = 128615, + [SMALL_STATE(2570)] = 128650, + [SMALL_STATE(2571)] = 128685, + [SMALL_STATE(2572)] = 128720, + [SMALL_STATE(2573)] = 128751, + [SMALL_STATE(2574)] = 128782, + [SMALL_STATE(2575)] = 128817, + [SMALL_STATE(2576)] = 128852, + [SMALL_STATE(2577)] = 128883, + [SMALL_STATE(2578)] = 128910, + [SMALL_STATE(2579)] = 128941, + [SMALL_STATE(2580)] = 128968, + [SMALL_STATE(2581)] = 129003, + [SMALL_STATE(2582)] = 129038, + [SMALL_STATE(2583)] = 129071, + [SMALL_STATE(2584)] = 129106, + [SMALL_STATE(2585)] = 129137, + [SMALL_STATE(2586)] = 129170, + [SMALL_STATE(2587)] = 129205, + [SMALL_STATE(2588)] = 129240, + [SMALL_STATE(2589)] = 129275, + [SMALL_STATE(2590)] = 129310, + [SMALL_STATE(2591)] = 129345, + [SMALL_STATE(2592)] = 129380, + [SMALL_STATE(2593)] = 129415, + [SMALL_STATE(2594)] = 129450, + [SMALL_STATE(2595)] = 129477, + [SMALL_STATE(2596)] = 129508, + [SMALL_STATE(2597)] = 129535, + [SMALL_STATE(2598)] = 129570, + [SMALL_STATE(2599)] = 129605, + [SMALL_STATE(2600)] = 129634, + [SMALL_STATE(2601)] = 129665, + [SMALL_STATE(2602)] = 129700, + [SMALL_STATE(2603)] = 129729, + [SMALL_STATE(2604)] = 129756, + [SMALL_STATE(2605)] = 129791, + [SMALL_STATE(2606)] = 129826, + [SMALL_STATE(2607)] = 129861, + [SMALL_STATE(2608)] = 129896, + [SMALL_STATE(2609)] = 129931, + [SMALL_STATE(2610)] = 129966, + [SMALL_STATE(2611)] = 129993, + [SMALL_STATE(2612)] = 130028, + [SMALL_STATE(2613)] = 130055, + [SMALL_STATE(2614)] = 130082, + [SMALL_STATE(2615)] = 130109, + [SMALL_STATE(2616)] = 130144, + [SMALL_STATE(2617)] = 130173, + [SMALL_STATE(2618)] = 130208, + [SMALL_STATE(2619)] = 130235, + [SMALL_STATE(2620)] = 130270, + [SMALL_STATE(2621)] = 130305, + [SMALL_STATE(2622)] = 130340, + [SMALL_STATE(2623)] = 130375, + [SMALL_STATE(2624)] = 130404, + [SMALL_STATE(2625)] = 130431, + [SMALL_STATE(2626)] = 130458, + [SMALL_STATE(2627)] = 130485, + [SMALL_STATE(2628)] = 130516, + [SMALL_STATE(2629)] = 130548, + [SMALL_STATE(2630)] = 130580, + [SMALL_STATE(2631)] = 130612, + [SMALL_STATE(2632)] = 130638, + [SMALL_STATE(2633)] = 130670, + [SMALL_STATE(2634)] = 130698, + [SMALL_STATE(2635)] = 130730, + [SMALL_STATE(2636)] = 130762, + [SMALL_STATE(2637)] = 130788, + [SMALL_STATE(2638)] = 130814, + [SMALL_STATE(2639)] = 130846, + [SMALL_STATE(2640)] = 130878, + [SMALL_STATE(2641)] = 130910, + [SMALL_STATE(2642)] = 130942, + [SMALL_STATE(2643)] = 130974, + [SMALL_STATE(2644)] = 131006, + [SMALL_STATE(2645)] = 131038, + [SMALL_STATE(2646)] = 131070, + [SMALL_STATE(2647)] = 131102, + [SMALL_STATE(2648)] = 131134, + [SMALL_STATE(2649)] = 131162, + [SMALL_STATE(2650)] = 131194, + [SMALL_STATE(2651)] = 131226, + [SMALL_STATE(2652)] = 131254, + [SMALL_STATE(2653)] = 131284, + [SMALL_STATE(2654)] = 131314, + [SMALL_STATE(2655)] = 131342, + [SMALL_STATE(2656)] = 131368, + [SMALL_STATE(2657)] = 131400, + [SMALL_STATE(2658)] = 131432, + [SMALL_STATE(2659)] = 131464, + [SMALL_STATE(2660)] = 131492, + [SMALL_STATE(2661)] = 131518, + [SMALL_STATE(2662)] = 131546, + [SMALL_STATE(2663)] = 131578, + [SMALL_STATE(2664)] = 131608, + [SMALL_STATE(2665)] = 131640, + [SMALL_STATE(2666)] = 131668, + [SMALL_STATE(2667)] = 131700, + [SMALL_STATE(2668)] = 131726, + [SMALL_STATE(2669)] = 131758, + [SMALL_STATE(2670)] = 131784, + [SMALL_STATE(2671)] = 131816, + [SMALL_STATE(2672)] = 131844, + [SMALL_STATE(2673)] = 131874, + [SMALL_STATE(2674)] = 131906, + [SMALL_STATE(2675)] = 131938, + [SMALL_STATE(2676)] = 131970, + [SMALL_STATE(2677)] = 132002, + [SMALL_STATE(2678)] = 132028, + [SMALL_STATE(2679)] = 132060, + [SMALL_STATE(2680)] = 132092, + [SMALL_STATE(2681)] = 132124, + [SMALL_STATE(2682)] = 132156, + [SMALL_STATE(2683)] = 132182, + [SMALL_STATE(2684)] = 132208, + [SMALL_STATE(2685)] = 132240, + [SMALL_STATE(2686)] = 132268, + [SMALL_STATE(2687)] = 132300, + [SMALL_STATE(2688)] = 132332, + [SMALL_STATE(2689)] = 132360, + [SMALL_STATE(2690)] = 132390, + [SMALL_STATE(2691)] = 132416, + [SMALL_STATE(2692)] = 132442, + [SMALL_STATE(2693)] = 132474, + [SMALL_STATE(2694)] = 132502, + [SMALL_STATE(2695)] = 132532, + [SMALL_STATE(2696)] = 132564, + [SMALL_STATE(2697)] = 132596, + [SMALL_STATE(2698)] = 132624, + [SMALL_STATE(2699)] = 132652, + [SMALL_STATE(2700)] = 132684, + [SMALL_STATE(2701)] = 132712, + [SMALL_STATE(2702)] = 132744, + [SMALL_STATE(2703)] = 132772, + [SMALL_STATE(2704)] = 132802, + [SMALL_STATE(2705)] = 132834, + [SMALL_STATE(2706)] = 132862, + [SMALL_STATE(2707)] = 132888, + [SMALL_STATE(2708)] = 132916, + [SMALL_STATE(2709)] = 132945, + [SMALL_STATE(2710)] = 132974, + [SMALL_STATE(2711)] = 133003, + [SMALL_STATE(2712)] = 133032, + [SMALL_STATE(2713)] = 133061, + [SMALL_STATE(2714)] = 133090, + [SMALL_STATE(2715)] = 133117, + [SMALL_STATE(2716)] = 133146, + [SMALL_STATE(2717)] = 133175, + [SMALL_STATE(2718)] = 133204, + [SMALL_STATE(2719)] = 133231, + [SMALL_STATE(2720)] = 133258, + [SMALL_STATE(2721)] = 133285, + [SMALL_STATE(2722)] = 133314, + [SMALL_STATE(2723)] = 133343, + [SMALL_STATE(2724)] = 133372, + [SMALL_STATE(2725)] = 133397, + [SMALL_STATE(2726)] = 133426, + [SMALL_STATE(2727)] = 133455, + [SMALL_STATE(2728)] = 133484, + [SMALL_STATE(2729)] = 133511, + [SMALL_STATE(2730)] = 133540, + [SMALL_STATE(2731)] = 133565, + [SMALL_STATE(2732)] = 133592, + [SMALL_STATE(2733)] = 133621, + [SMALL_STATE(2734)] = 133648, + [SMALL_STATE(2735)] = 133677, + [SMALL_STATE(2736)] = 133706, + [SMALL_STATE(2737)] = 133735, + [SMALL_STATE(2738)] = 133764, + [SMALL_STATE(2739)] = 133789, + [SMALL_STATE(2740)] = 133818, + [SMALL_STATE(2741)] = 133847, + [SMALL_STATE(2742)] = 133876, + [SMALL_STATE(2743)] = 133901, + [SMALL_STATE(2744)] = 133930, + [SMALL_STATE(2745)] = 133955, + [SMALL_STATE(2746)] = 133984, + [SMALL_STATE(2747)] = 134013, + [SMALL_STATE(2748)] = 134042, + [SMALL_STATE(2749)] = 134071, + [SMALL_STATE(2750)] = 134100, + [SMALL_STATE(2751)] = 134129, + [SMALL_STATE(2752)] = 134156, + [SMALL_STATE(2753)] = 134185, + [SMALL_STATE(2754)] = 134214, + [SMALL_STATE(2755)] = 134239, + [SMALL_STATE(2756)] = 134268, + [SMALL_STATE(2757)] = 134293, + [SMALL_STATE(2758)] = 134322, + [SMALL_STATE(2759)] = 134351, + [SMALL_STATE(2760)] = 134376, + [SMALL_STATE(2761)] = 134405, + [SMALL_STATE(2762)] = 134434, + [SMALL_STATE(2763)] = 134463, + [SMALL_STATE(2764)] = 134492, + [SMALL_STATE(2765)] = 134521, + [SMALL_STATE(2766)] = 134550, + [SMALL_STATE(2767)] = 134579, + [SMALL_STATE(2768)] = 134608, + [SMALL_STATE(2769)] = 134637, + [SMALL_STATE(2770)] = 134666, + [SMALL_STATE(2771)] = 134691, + [SMALL_STATE(2772)] = 134720, + [SMALL_STATE(2773)] = 134749, + [SMALL_STATE(2774)] = 134778, + [SMALL_STATE(2775)] = 134807, + [SMALL_STATE(2776)] = 134836, + [SMALL_STATE(2777)] = 134865, + [SMALL_STATE(2778)] = 134894, + [SMALL_STATE(2779)] = 134923, + [SMALL_STATE(2780)] = 134952, + [SMALL_STATE(2781)] = 134981, + [SMALL_STATE(2782)] = 135010, + [SMALL_STATE(2783)] = 135039, + [SMALL_STATE(2784)] = 135068, + [SMALL_STATE(2785)] = 135097, + [SMALL_STATE(2786)] = 135126, + [SMALL_STATE(2787)] = 135153, + [SMALL_STATE(2788)] = 135180, + [SMALL_STATE(2789)] = 135209, + [SMALL_STATE(2790)] = 135238, + [SMALL_STATE(2791)] = 135267, + [SMALL_STATE(2792)] = 135296, + [SMALL_STATE(2793)] = 135325, + [SMALL_STATE(2794)] = 135354, + [SMALL_STATE(2795)] = 135383, + [SMALL_STATE(2796)] = 135412, + [SMALL_STATE(2797)] = 135441, + [SMALL_STATE(2798)] = 135468, + [SMALL_STATE(2799)] = 135497, + [SMALL_STATE(2800)] = 135526, + [SMALL_STATE(2801)] = 135555, + [SMALL_STATE(2802)] = 135584, + [SMALL_STATE(2803)] = 135611, + [SMALL_STATE(2804)] = 135640, + [SMALL_STATE(2805)] = 135669, + [SMALL_STATE(2806)] = 135698, + [SMALL_STATE(2807)] = 135727, + [SMALL_STATE(2808)] = 135756, + [SMALL_STATE(2809)] = 135785, + [SMALL_STATE(2810)] = 135814, + [SMALL_STATE(2811)] = 135843, + [SMALL_STATE(2812)] = 135872, + [SMALL_STATE(2813)] = 135901, + [SMALL_STATE(2814)] = 135930, + [SMALL_STATE(2815)] = 135959, + [SMALL_STATE(2816)] = 135988, + [SMALL_STATE(2817)] = 136017, + [SMALL_STATE(2818)] = 136046, + [SMALL_STATE(2819)] = 136075, + [SMALL_STATE(2820)] = 136104, + [SMALL_STATE(2821)] = 136131, + [SMALL_STATE(2822)] = 136160, + [SMALL_STATE(2823)] = 136189, + [SMALL_STATE(2824)] = 136214, + [SMALL_STATE(2825)] = 136243, + [SMALL_STATE(2826)] = 136268, + [SMALL_STATE(2827)] = 136297, + [SMALL_STATE(2828)] = 136326, + [SMALL_STATE(2829)] = 136355, + [SMALL_STATE(2830)] = 136384, + [SMALL_STATE(2831)] = 136413, + [SMALL_STATE(2832)] = 136440, + [SMALL_STATE(2833)] = 136469, + [SMALL_STATE(2834)] = 136498, + [SMALL_STATE(2835)] = 136527, + [SMALL_STATE(2836)] = 136556, + [SMALL_STATE(2837)] = 136585, + [SMALL_STATE(2838)] = 136614, + [SMALL_STATE(2839)] = 136643, + [SMALL_STATE(2840)] = 136672, + [SMALL_STATE(2841)] = 136701, + [SMALL_STATE(2842)] = 136730, + [SMALL_STATE(2843)] = 136759, + [SMALL_STATE(2844)] = 136788, + [SMALL_STATE(2845)] = 136817, + [SMALL_STATE(2846)] = 136846, + [SMALL_STATE(2847)] = 136875, + [SMALL_STATE(2848)] = 136904, + [SMALL_STATE(2849)] = 136933, + [SMALL_STATE(2850)] = 136958, + [SMALL_STATE(2851)] = 136987, + [SMALL_STATE(2852)] = 137014, + [SMALL_STATE(2853)] = 137043, + [SMALL_STATE(2854)] = 137072, + [SMALL_STATE(2855)] = 137101, + [SMALL_STATE(2856)] = 137130, + [SMALL_STATE(2857)] = 137159, + [SMALL_STATE(2858)] = 137188, + [SMALL_STATE(2859)] = 137213, + [SMALL_STATE(2860)] = 137242, + [SMALL_STATE(2861)] = 137269, + [SMALL_STATE(2862)] = 137298, + [SMALL_STATE(2863)] = 137327, + [SMALL_STATE(2864)] = 137356, + [SMALL_STATE(2865)] = 137385, + [SMALL_STATE(2866)] = 137414, + [SMALL_STATE(2867)] = 137443, + [SMALL_STATE(2868)] = 137472, + [SMALL_STATE(2869)] = 137501, + [SMALL_STATE(2870)] = 137530, + [SMALL_STATE(2871)] = 137559, + [SMALL_STATE(2872)] = 137588, + [SMALL_STATE(2873)] = 137617, + [SMALL_STATE(2874)] = 137646, + [SMALL_STATE(2875)] = 137675, + [SMALL_STATE(2876)] = 137704, + [SMALL_STATE(2877)] = 137733, + [SMALL_STATE(2878)] = 137762, + [SMALL_STATE(2879)] = 137791, + [SMALL_STATE(2880)] = 137820, + [SMALL_STATE(2881)] = 137849, + [SMALL_STATE(2882)] = 137878, + [SMALL_STATE(2883)] = 137907, + [SMALL_STATE(2884)] = 137936, + [SMALL_STATE(2885)] = 137963, + [SMALL_STATE(2886)] = 137992, + [SMALL_STATE(2887)] = 138021, + [SMALL_STATE(2888)] = 138050, + [SMALL_STATE(2889)] = 138079, + [SMALL_STATE(2890)] = 138108, + [SMALL_STATE(2891)] = 138137, + [SMALL_STATE(2892)] = 138166, + [SMALL_STATE(2893)] = 138195, + [SMALL_STATE(2894)] = 138224, + [SMALL_STATE(2895)] = 138251, + [SMALL_STATE(2896)] = 138278, + [SMALL_STATE(2897)] = 138307, + [SMALL_STATE(2898)] = 138336, + [SMALL_STATE(2899)] = 138365, + [SMALL_STATE(2900)] = 138392, + [SMALL_STATE(2901)] = 138421, + [SMALL_STATE(2902)] = 138450, + [SMALL_STATE(2903)] = 138479, + [SMALL_STATE(2904)] = 138508, + [SMALL_STATE(2905)] = 138537, + [SMALL_STATE(2906)] = 138566, + [SMALL_STATE(2907)] = 138595, + [SMALL_STATE(2908)] = 138622, + [SMALL_STATE(2909)] = 138649, + [SMALL_STATE(2910)] = 138678, + [SMALL_STATE(2911)] = 138703, + [SMALL_STATE(2912)] = 138732, + [SMALL_STATE(2913)] = 138761, + [SMALL_STATE(2914)] = 138790, + [SMALL_STATE(2915)] = 138819, + [SMALL_STATE(2916)] = 138844, + [SMALL_STATE(2917)] = 138873, + [SMALL_STATE(2918)] = 138902, + [SMALL_STATE(2919)] = 138931, + [SMALL_STATE(2920)] = 138960, + [SMALL_STATE(2921)] = 138989, + [SMALL_STATE(2922)] = 139018, + [SMALL_STATE(2923)] = 139047, + [SMALL_STATE(2924)] = 139076, + [SMALL_STATE(2925)] = 139105, + [SMALL_STATE(2926)] = 139134, + [SMALL_STATE(2927)] = 139163, + [SMALL_STATE(2928)] = 139192, + [SMALL_STATE(2929)] = 139221, + [SMALL_STATE(2930)] = 139250, + [SMALL_STATE(2931)] = 139279, + [SMALL_STATE(2932)] = 139308, + [SMALL_STATE(2933)] = 139337, + [SMALL_STATE(2934)] = 139364, + [SMALL_STATE(2935)] = 139393, + [SMALL_STATE(2936)] = 139422, + [SMALL_STATE(2937)] = 139451, + [SMALL_STATE(2938)] = 139480, + [SMALL_STATE(2939)] = 139509, + [SMALL_STATE(2940)] = 139538, + [SMALL_STATE(2941)] = 139567, + [SMALL_STATE(2942)] = 139596, + [SMALL_STATE(2943)] = 139623, + [SMALL_STATE(2944)] = 139652, + [SMALL_STATE(2945)] = 139681, + [SMALL_STATE(2946)] = 139708, + [SMALL_STATE(2947)] = 139737, + [SMALL_STATE(2948)] = 139766, + [SMALL_STATE(2949)] = 139791, + [SMALL_STATE(2950)] = 139820, + [SMALL_STATE(2951)] = 139849, + [SMALL_STATE(2952)] = 139878, + [SMALL_STATE(2953)] = 139907, + [SMALL_STATE(2954)] = 139936, + [SMALL_STATE(2955)] = 139965, + [SMALL_STATE(2956)] = 139994, + [SMALL_STATE(2957)] = 140023, + [SMALL_STATE(2958)] = 140052, + [SMALL_STATE(2959)] = 140081, + [SMALL_STATE(2960)] = 140110, + [SMALL_STATE(2961)] = 140139, + [SMALL_STATE(2962)] = 140168, + [SMALL_STATE(2963)] = 140197, + [SMALL_STATE(2964)] = 140226, + [SMALL_STATE(2965)] = 140255, + [SMALL_STATE(2966)] = 140284, + [SMALL_STATE(2967)] = 140313, + [SMALL_STATE(2968)] = 140342, + [SMALL_STATE(2969)] = 140371, + [SMALL_STATE(2970)] = 140400, + [SMALL_STATE(2971)] = 140429, + [SMALL_STATE(2972)] = 140458, + [SMALL_STATE(2973)] = 140487, + [SMALL_STATE(2974)] = 140516, + [SMALL_STATE(2975)] = 140545, + [SMALL_STATE(2976)] = 140574, + [SMALL_STATE(2977)] = 140603, + [SMALL_STATE(2978)] = 140632, + [SMALL_STATE(2979)] = 140659, + [SMALL_STATE(2980)] = 140688, + [SMALL_STATE(2981)] = 140717, + [SMALL_STATE(2982)] = 140746, + [SMALL_STATE(2983)] = 140771, + [SMALL_STATE(2984)] = 140798, + [SMALL_STATE(2985)] = 140827, + [SMALL_STATE(2986)] = 140856, + [SMALL_STATE(2987)] = 140885, + [SMALL_STATE(2988)] = 140914, + [SMALL_STATE(2989)] = 140943, + [SMALL_STATE(2990)] = 140972, + [SMALL_STATE(2991)] = 141001, + [SMALL_STATE(2992)] = 141030, + [SMALL_STATE(2993)] = 141059, + [SMALL_STATE(2994)] = 141088, + [SMALL_STATE(2995)] = 141117, + [SMALL_STATE(2996)] = 141146, + [SMALL_STATE(2997)] = 141173, + [SMALL_STATE(2998)] = 141198, + [SMALL_STATE(2999)] = 141227, + [SMALL_STATE(3000)] = 141256, + [SMALL_STATE(3001)] = 141281, + [SMALL_STATE(3002)] = 141310, + [SMALL_STATE(3003)] = 141339, + [SMALL_STATE(3004)] = 141368, + [SMALL_STATE(3005)] = 141397, + [SMALL_STATE(3006)] = 141426, + [SMALL_STATE(3007)] = 141455, + [SMALL_STATE(3008)] = 141484, + [SMALL_STATE(3009)] = 141513, + [SMALL_STATE(3010)] = 141542, + [SMALL_STATE(3011)] = 141571, + [SMALL_STATE(3012)] = 141600, + [SMALL_STATE(3013)] = 141629, + [SMALL_STATE(3014)] = 141654, + [SMALL_STATE(3015)] = 141683, + [SMALL_STATE(3016)] = 141712, + [SMALL_STATE(3017)] = 141741, + [SMALL_STATE(3018)] = 141770, + [SMALL_STATE(3019)] = 141799, + [SMALL_STATE(3020)] = 141828, + [SMALL_STATE(3021)] = 141857, + [SMALL_STATE(3022)] = 141886, + [SMALL_STATE(3023)] = 141915, + [SMALL_STATE(3024)] = 141944, + [SMALL_STATE(3025)] = 141973, + [SMALL_STATE(3026)] = 142002, + [SMALL_STATE(3027)] = 142031, + [SMALL_STATE(3028)] = 142060, + [SMALL_STATE(3029)] = 142089, + [SMALL_STATE(3030)] = 142114, + [SMALL_STATE(3031)] = 142143, + [SMALL_STATE(3032)] = 142172, + [SMALL_STATE(3033)] = 142201, + [SMALL_STATE(3034)] = 142230, + [SMALL_STATE(3035)] = 142259, + [SMALL_STATE(3036)] = 142288, + [SMALL_STATE(3037)] = 142317, + [SMALL_STATE(3038)] = 142346, + [SMALL_STATE(3039)] = 142375, + [SMALL_STATE(3040)] = 142404, + [SMALL_STATE(3041)] = 142431, + [SMALL_STATE(3042)] = 142460, + [SMALL_STATE(3043)] = 142489, + [SMALL_STATE(3044)] = 142518, + [SMALL_STATE(3045)] = 142547, + [SMALL_STATE(3046)] = 142576, + [SMALL_STATE(3047)] = 142605, + [SMALL_STATE(3048)] = 142631, + [SMALL_STATE(3049)] = 142657, + [SMALL_STATE(3050)] = 142683, + [SMALL_STATE(3051)] = 142709, + [SMALL_STATE(3052)] = 142735, + [SMALL_STATE(3053)] = 142761, + [SMALL_STATE(3054)] = 142787, + [SMALL_STATE(3055)] = 142813, + [SMALL_STATE(3056)] = 142839, + [SMALL_STATE(3057)] = 142865, + [SMALL_STATE(3058)] = 142891, + [SMALL_STATE(3059)] = 142917, + [SMALL_STATE(3060)] = 142943, + [SMALL_STATE(3061)] = 142969, + [SMALL_STATE(3062)] = 142995, + [SMALL_STATE(3063)] = 143021, + [SMALL_STATE(3064)] = 143047, + [SMALL_STATE(3065)] = 143073, + [SMALL_STATE(3066)] = 143099, + [SMALL_STATE(3067)] = 143125, + [SMALL_STATE(3068)] = 143151, + [SMALL_STATE(3069)] = 143175, + [SMALL_STATE(3070)] = 143201, + [SMALL_STATE(3071)] = 143225, + [SMALL_STATE(3072)] = 143251, + [SMALL_STATE(3073)] = 143277, + [SMALL_STATE(3074)] = 143303, + [SMALL_STATE(3075)] = 143327, + [SMALL_STATE(3076)] = 143351, + [SMALL_STATE(3077)] = 143377, + [SMALL_STATE(3078)] = 143403, + [SMALL_STATE(3079)] = 143429, + [SMALL_STATE(3080)] = 143455, + [SMALL_STATE(3081)] = 143481, + [SMALL_STATE(3082)] = 143505, + [SMALL_STATE(3083)] = 143531, + [SMALL_STATE(3084)] = 143557, + [SMALL_STATE(3085)] = 143583, + [SMALL_STATE(3086)] = 143609, + [SMALL_STATE(3087)] = 143633, + [SMALL_STATE(3088)] = 143659, + [SMALL_STATE(3089)] = 143683, + [SMALL_STATE(3090)] = 143709, + [SMALL_STATE(3091)] = 143735, + [SMALL_STATE(3092)] = 143761, + [SMALL_STATE(3093)] = 143787, + [SMALL_STATE(3094)] = 143813, + [SMALL_STATE(3095)] = 143839, + [SMALL_STATE(3096)] = 143865, + [SMALL_STATE(3097)] = 143889, + [SMALL_STATE(3098)] = 143915, + [SMALL_STATE(3099)] = 143941, + [SMALL_STATE(3100)] = 143967, + [SMALL_STATE(3101)] = 143993, + [SMALL_STATE(3102)] = 144017, + [SMALL_STATE(3103)] = 144043, + [SMALL_STATE(3104)] = 144069, + [SMALL_STATE(3105)] = 144093, + [SMALL_STATE(3106)] = 144117, + [SMALL_STATE(3107)] = 144143, + [SMALL_STATE(3108)] = 144169, + [SMALL_STATE(3109)] = 144193, + [SMALL_STATE(3110)] = 144219, + [SMALL_STATE(3111)] = 144245, + [SMALL_STATE(3112)] = 144271, + [SMALL_STATE(3113)] = 144297, + [SMALL_STATE(3114)] = 144323, + [SMALL_STATE(3115)] = 144349, + [SMALL_STATE(3116)] = 144375, + [SMALL_STATE(3117)] = 144399, + [SMALL_STATE(3118)] = 144423, + [SMALL_STATE(3119)] = 144449, + [SMALL_STATE(3120)] = 144475, + [SMALL_STATE(3121)] = 144499, + [SMALL_STATE(3122)] = 144525, + [SMALL_STATE(3123)] = 144551, + [SMALL_STATE(3124)] = 144575, + [SMALL_STATE(3125)] = 144601, + [SMALL_STATE(3126)] = 144627, + [SMALL_STATE(3127)] = 144653, + [SMALL_STATE(3128)] = 144677, + [SMALL_STATE(3129)] = 144703, + [SMALL_STATE(3130)] = 144729, + [SMALL_STATE(3131)] = 144753, + [SMALL_STATE(3132)] = 144779, + [SMALL_STATE(3133)] = 144805, + [SMALL_STATE(3134)] = 144831, + [SMALL_STATE(3135)] = 144855, + [SMALL_STATE(3136)] = 144879, + [SMALL_STATE(3137)] = 144905, + [SMALL_STATE(3138)] = 144929, + [SMALL_STATE(3139)] = 144955, + [SMALL_STATE(3140)] = 144981, + [SMALL_STATE(3141)] = 145005, + [SMALL_STATE(3142)] = 145029, + [SMALL_STATE(3143)] = 145055, + [SMALL_STATE(3144)] = 145081, + [SMALL_STATE(3145)] = 145107, + [SMALL_STATE(3146)] = 145133, + [SMALL_STATE(3147)] = 145159, + [SMALL_STATE(3148)] = 145183, + [SMALL_STATE(3149)] = 145209, + [SMALL_STATE(3150)] = 145233, + [SMALL_STATE(3151)] = 145259, + [SMALL_STATE(3152)] = 145285, + [SMALL_STATE(3153)] = 145311, + [SMALL_STATE(3154)] = 145337, + [SMALL_STATE(3155)] = 145363, + [SMALL_STATE(3156)] = 145387, + [SMALL_STATE(3157)] = 145413, + [SMALL_STATE(3158)] = 145439, + [SMALL_STATE(3159)] = 145465, + [SMALL_STATE(3160)] = 145491, + [SMALL_STATE(3161)] = 145515, + [SMALL_STATE(3162)] = 145539, + [SMALL_STATE(3163)] = 145565, + [SMALL_STATE(3164)] = 145589, + [SMALL_STATE(3165)] = 145615, + [SMALL_STATE(3166)] = 145641, + [SMALL_STATE(3167)] = 145667, + [SMALL_STATE(3168)] = 145693, + [SMALL_STATE(3169)] = 145719, + [SMALL_STATE(3170)] = 145743, + [SMALL_STATE(3171)] = 145769, + [SMALL_STATE(3172)] = 145793, + [SMALL_STATE(3173)] = 145819, + [SMALL_STATE(3174)] = 145843, + [SMALL_STATE(3175)] = 145867, + [SMALL_STATE(3176)] = 145893, + [SMALL_STATE(3177)] = 145919, + [SMALL_STATE(3178)] = 145943, + [SMALL_STATE(3179)] = 145969, + [SMALL_STATE(3180)] = 145993, + [SMALL_STATE(3181)] = 146019, + [SMALL_STATE(3182)] = 146045, + [SMALL_STATE(3183)] = 146071, + [SMALL_STATE(3184)] = 146097, + [SMALL_STATE(3185)] = 146123, + [SMALL_STATE(3186)] = 146149, + [SMALL_STATE(3187)] = 146175, + [SMALL_STATE(3188)] = 146201, + [SMALL_STATE(3189)] = 146225, + [SMALL_STATE(3190)] = 146251, + [SMALL_STATE(3191)] = 146277, + [SMALL_STATE(3192)] = 146303, + [SMALL_STATE(3193)] = 146327, + [SMALL_STATE(3194)] = 146353, + [SMALL_STATE(3195)] = 146377, + [SMALL_STATE(3196)] = 146403, + [SMALL_STATE(3197)] = 146427, + [SMALL_STATE(3198)] = 146453, + [SMALL_STATE(3199)] = 146479, + [SMALL_STATE(3200)] = 146505, + [SMALL_STATE(3201)] = 146529, + [SMALL_STATE(3202)] = 146555, + [SMALL_STATE(3203)] = 146581, + [SMALL_STATE(3204)] = 146607, + [SMALL_STATE(3205)] = 146631, + [SMALL_STATE(3206)] = 146657, + [SMALL_STATE(3207)] = 146683, + [SMALL_STATE(3208)] = 146709, + [SMALL_STATE(3209)] = 146735, + [SMALL_STATE(3210)] = 146761, + [SMALL_STATE(3211)] = 146787, + [SMALL_STATE(3212)] = 146813, + [SMALL_STATE(3213)] = 146839, + [SMALL_STATE(3214)] = 146865, + [SMALL_STATE(3215)] = 146891, + [SMALL_STATE(3216)] = 146917, + [SMALL_STATE(3217)] = 146943, + [SMALL_STATE(3218)] = 146967, + [SMALL_STATE(3219)] = 146991, + [SMALL_STATE(3220)] = 147017, + [SMALL_STATE(3221)] = 147041, + [SMALL_STATE(3222)] = 147067, + [SMALL_STATE(3223)] = 147093, + [SMALL_STATE(3224)] = 147117, + [SMALL_STATE(3225)] = 147143, + [SMALL_STATE(3226)] = 147169, + [SMALL_STATE(3227)] = 147195, + [SMALL_STATE(3228)] = 147221, + [SMALL_STATE(3229)] = 147247, + [SMALL_STATE(3230)] = 147271, + [SMALL_STATE(3231)] = 147297, + [SMALL_STATE(3232)] = 147323, + [SMALL_STATE(3233)] = 147349, + [SMALL_STATE(3234)] = 147375, + [SMALL_STATE(3235)] = 147399, + [SMALL_STATE(3236)] = 147425, + [SMALL_STATE(3237)] = 147451, + [SMALL_STATE(3238)] = 147477, + [SMALL_STATE(3239)] = 147503, + [SMALL_STATE(3240)] = 147529, + [SMALL_STATE(3241)] = 147553, + [SMALL_STATE(3242)] = 147579, + [SMALL_STATE(3243)] = 147603, + [SMALL_STATE(3244)] = 147629, + [SMALL_STATE(3245)] = 147655, + [SMALL_STATE(3246)] = 147681, + [SMALL_STATE(3247)] = 147707, + [SMALL_STATE(3248)] = 147733, + [SMALL_STATE(3249)] = 147757, + [SMALL_STATE(3250)] = 147783, + [SMALL_STATE(3251)] = 147809, + [SMALL_STATE(3252)] = 147833, + [SMALL_STATE(3253)] = 147859, + [SMALL_STATE(3254)] = 147885, + [SMALL_STATE(3255)] = 147911, + [SMALL_STATE(3256)] = 147937, + [SMALL_STATE(3257)] = 147963, + [SMALL_STATE(3258)] = 147989, + [SMALL_STATE(3259)] = 148015, + [SMALL_STATE(3260)] = 148041, + [SMALL_STATE(3261)] = 148067, + [SMALL_STATE(3262)] = 148091, + [SMALL_STATE(3263)] = 148117, + [SMALL_STATE(3264)] = 148143, + [SMALL_STATE(3265)] = 148169, + [SMALL_STATE(3266)] = 148195, + [SMALL_STATE(3267)] = 148221, + [SMALL_STATE(3268)] = 148247, + [SMALL_STATE(3269)] = 148273, + [SMALL_STATE(3270)] = 148299, + [SMALL_STATE(3271)] = 148325, + [SMALL_STATE(3272)] = 148351, + [SMALL_STATE(3273)] = 148377, + [SMALL_STATE(3274)] = 148401, + [SMALL_STATE(3275)] = 148427, + [SMALL_STATE(3276)] = 148453, + [SMALL_STATE(3277)] = 148479, + [SMALL_STATE(3278)] = 148505, + [SMALL_STATE(3279)] = 148531, + [SMALL_STATE(3280)] = 148557, + [SMALL_STATE(3281)] = 148583, + [SMALL_STATE(3282)] = 148609, + [SMALL_STATE(3283)] = 148635, + [SMALL_STATE(3284)] = 148661, + [SMALL_STATE(3285)] = 148687, + [SMALL_STATE(3286)] = 148713, + [SMALL_STATE(3287)] = 148739, + [SMALL_STATE(3288)] = 148765, + [SMALL_STATE(3289)] = 148791, + [SMALL_STATE(3290)] = 148817, + [SMALL_STATE(3291)] = 148841, + [SMALL_STATE(3292)] = 148867, + [SMALL_STATE(3293)] = 148891, + [SMALL_STATE(3294)] = 148917, + [SMALL_STATE(3295)] = 148943, + [SMALL_STATE(3296)] = 148969, + [SMALL_STATE(3297)] = 148993, + [SMALL_STATE(3298)] = 149019, + [SMALL_STATE(3299)] = 149045, + [SMALL_STATE(3300)] = 149071, + [SMALL_STATE(3301)] = 149097, + [SMALL_STATE(3302)] = 149123, + [SMALL_STATE(3303)] = 149147, + [SMALL_STATE(3304)] = 149173, + [SMALL_STATE(3305)] = 149199, + [SMALL_STATE(3306)] = 149223, + [SMALL_STATE(3307)] = 149249, + [SMALL_STATE(3308)] = 149273, + [SMALL_STATE(3309)] = 149299, + [SMALL_STATE(3310)] = 149325, + [SMALL_STATE(3311)] = 149351, + [SMALL_STATE(3312)] = 149377, + [SMALL_STATE(3313)] = 149401, + [SMALL_STATE(3314)] = 149427, + [SMALL_STATE(3315)] = 149453, + [SMALL_STATE(3316)] = 149479, + [SMALL_STATE(3317)] = 149503, + [SMALL_STATE(3318)] = 149529, + [SMALL_STATE(3319)] = 149555, + [SMALL_STATE(3320)] = 149579, + [SMALL_STATE(3321)] = 149603, + [SMALL_STATE(3322)] = 149629, + [SMALL_STATE(3323)] = 149655, + [SMALL_STATE(3324)] = 149681, + [SMALL_STATE(3325)] = 149705, + [SMALL_STATE(3326)] = 149728, + [SMALL_STATE(3327)] = 149751, + [SMALL_STATE(3328)] = 149774, + [SMALL_STATE(3329)] = 149797, + [SMALL_STATE(3330)] = 149820, + [SMALL_STATE(3331)] = 149843, + [SMALL_STATE(3332)] = 149866, + [SMALL_STATE(3333)] = 149889, + [SMALL_STATE(3334)] = 149912, + [SMALL_STATE(3335)] = 149935, + [SMALL_STATE(3336)] = 149958, + [SMALL_STATE(3337)] = 149981, + [SMALL_STATE(3338)] = 150004, + [SMALL_STATE(3339)] = 150027, + [SMALL_STATE(3340)] = 150050, + [SMALL_STATE(3341)] = 150073, + [SMALL_STATE(3342)] = 150096, + [SMALL_STATE(3343)] = 150119, + [SMALL_STATE(3344)] = 150142, + [SMALL_STATE(3345)] = 150165, + [SMALL_STATE(3346)] = 150188, + [SMALL_STATE(3347)] = 150211, + [SMALL_STATE(3348)] = 150234, + [SMALL_STATE(3349)] = 150257, + [SMALL_STATE(3350)] = 150280, + [SMALL_STATE(3351)] = 150303, + [SMALL_STATE(3352)] = 150326, + [SMALL_STATE(3353)] = 150349, + [SMALL_STATE(3354)] = 150372, + [SMALL_STATE(3355)] = 150395, + [SMALL_STATE(3356)] = 150418, + [SMALL_STATE(3357)] = 150441, + [SMALL_STATE(3358)] = 150464, + [SMALL_STATE(3359)] = 150487, + [SMALL_STATE(3360)] = 150510, + [SMALL_STATE(3361)] = 150533, + [SMALL_STATE(3362)] = 150556, + [SMALL_STATE(3363)] = 150579, + [SMALL_STATE(3364)] = 150602, + [SMALL_STATE(3365)] = 150625, + [SMALL_STATE(3366)] = 150648, + [SMALL_STATE(3367)] = 150671, + [SMALL_STATE(3368)] = 150694, + [SMALL_STATE(3369)] = 150717, + [SMALL_STATE(3370)] = 150740, + [SMALL_STATE(3371)] = 150763, + [SMALL_STATE(3372)] = 150786, + [SMALL_STATE(3373)] = 150809, + [SMALL_STATE(3374)] = 150832, + [SMALL_STATE(3375)] = 150855, + [SMALL_STATE(3376)] = 150878, + [SMALL_STATE(3377)] = 150901, + [SMALL_STATE(3378)] = 150924, + [SMALL_STATE(3379)] = 150947, + [SMALL_STATE(3380)] = 150970, + [SMALL_STATE(3381)] = 150993, + [SMALL_STATE(3382)] = 151016, + [SMALL_STATE(3383)] = 151039, + [SMALL_STATE(3384)] = 151062, + [SMALL_STATE(3385)] = 151085, + [SMALL_STATE(3386)] = 151108, + [SMALL_STATE(3387)] = 151131, + [SMALL_STATE(3388)] = 151154, + [SMALL_STATE(3389)] = 151177, + [SMALL_STATE(3390)] = 151200, + [SMALL_STATE(3391)] = 151223, + [SMALL_STATE(3392)] = 151246, + [SMALL_STATE(3393)] = 151269, + [SMALL_STATE(3394)] = 151292, + [SMALL_STATE(3395)] = 151315, + [SMALL_STATE(3396)] = 151338, + [SMALL_STATE(3397)] = 151361, + [SMALL_STATE(3398)] = 151384, + [SMALL_STATE(3399)] = 151407, + [SMALL_STATE(3400)] = 151430, + [SMALL_STATE(3401)] = 151453, + [SMALL_STATE(3402)] = 151476, + [SMALL_STATE(3403)] = 151499, + [SMALL_STATE(3404)] = 151522, + [SMALL_STATE(3405)] = 151545, + [SMALL_STATE(3406)] = 151568, + [SMALL_STATE(3407)] = 151591, + [SMALL_STATE(3408)] = 151614, + [SMALL_STATE(3409)] = 151637, + [SMALL_STATE(3410)] = 151660, + [SMALL_STATE(3411)] = 151683, + [SMALL_STATE(3412)] = 151706, + [SMALL_STATE(3413)] = 151729, + [SMALL_STATE(3414)] = 151752, + [SMALL_STATE(3415)] = 151775, + [SMALL_STATE(3416)] = 151798, + [SMALL_STATE(3417)] = 151821, + [SMALL_STATE(3418)] = 151844, + [SMALL_STATE(3419)] = 151867, + [SMALL_STATE(3420)] = 151890, + [SMALL_STATE(3421)] = 151913, + [SMALL_STATE(3422)] = 151936, + [SMALL_STATE(3423)] = 151959, + [SMALL_STATE(3424)] = 151982, + [SMALL_STATE(3425)] = 152005, + [SMALL_STATE(3426)] = 152028, + [SMALL_STATE(3427)] = 152051, + [SMALL_STATE(3428)] = 152074, + [SMALL_STATE(3429)] = 152097, + [SMALL_STATE(3430)] = 152120, + [SMALL_STATE(3431)] = 152143, + [SMALL_STATE(3432)] = 152166, + [SMALL_STATE(3433)] = 152189, + [SMALL_STATE(3434)] = 152212, + [SMALL_STATE(3435)] = 152235, + [SMALL_STATE(3436)] = 152258, + [SMALL_STATE(3437)] = 152281, + [SMALL_STATE(3438)] = 152304, + [SMALL_STATE(3439)] = 152327, + [SMALL_STATE(3440)] = 152350, + [SMALL_STATE(3441)] = 152373, + [SMALL_STATE(3442)] = 152396, + [SMALL_STATE(3443)] = 152419, + [SMALL_STATE(3444)] = 152442, + [SMALL_STATE(3445)] = 152465, + [SMALL_STATE(3446)] = 152488, + [SMALL_STATE(3447)] = 152511, + [SMALL_STATE(3448)] = 152534, + [SMALL_STATE(3449)] = 152557, + [SMALL_STATE(3450)] = 152580, + [SMALL_STATE(3451)] = 152603, + [SMALL_STATE(3452)] = 152626, + [SMALL_STATE(3453)] = 152649, + [SMALL_STATE(3454)] = 152672, + [SMALL_STATE(3455)] = 152695, + [SMALL_STATE(3456)] = 152718, + [SMALL_STATE(3457)] = 152741, + [SMALL_STATE(3458)] = 152764, + [SMALL_STATE(3459)] = 152787, + [SMALL_STATE(3460)] = 152810, + [SMALL_STATE(3461)] = 152833, + [SMALL_STATE(3462)] = 152856, + [SMALL_STATE(3463)] = 152879, + [SMALL_STATE(3464)] = 152902, + [SMALL_STATE(3465)] = 152925, + [SMALL_STATE(3466)] = 152948, + [SMALL_STATE(3467)] = 152971, + [SMALL_STATE(3468)] = 152994, + [SMALL_STATE(3469)] = 153017, + [SMALL_STATE(3470)] = 153040, + [SMALL_STATE(3471)] = 153063, + [SMALL_STATE(3472)] = 153086, + [SMALL_STATE(3473)] = 153109, + [SMALL_STATE(3474)] = 153132, + [SMALL_STATE(3475)] = 153155, + [SMALL_STATE(3476)] = 153178, + [SMALL_STATE(3477)] = 153201, + [SMALL_STATE(3478)] = 153224, + [SMALL_STATE(3479)] = 153247, + [SMALL_STATE(3480)] = 153270, + [SMALL_STATE(3481)] = 153293, + [SMALL_STATE(3482)] = 153316, + [SMALL_STATE(3483)] = 153339, + [SMALL_STATE(3484)] = 153362, + [SMALL_STATE(3485)] = 153385, + [SMALL_STATE(3486)] = 153408, + [SMALL_STATE(3487)] = 153431, + [SMALL_STATE(3488)] = 153454, + [SMALL_STATE(3489)] = 153477, + [SMALL_STATE(3490)] = 153500, + [SMALL_STATE(3491)] = 153523, + [SMALL_STATE(3492)] = 153546, + [SMALL_STATE(3493)] = 153569, + [SMALL_STATE(3494)] = 153592, + [SMALL_STATE(3495)] = 153615, + [SMALL_STATE(3496)] = 153638, + [SMALL_STATE(3497)] = 153661, + [SMALL_STATE(3498)] = 153684, + [SMALL_STATE(3499)] = 153707, + [SMALL_STATE(3500)] = 153730, + [SMALL_STATE(3501)] = 153753, + [SMALL_STATE(3502)] = 153776, + [SMALL_STATE(3503)] = 153799, + [SMALL_STATE(3504)] = 153822, + [SMALL_STATE(3505)] = 153845, + [SMALL_STATE(3506)] = 153868, + [SMALL_STATE(3507)] = 153891, + [SMALL_STATE(3508)] = 153914, + [SMALL_STATE(3509)] = 153937, + [SMALL_STATE(3510)] = 153960, + [SMALL_STATE(3511)] = 153983, + [SMALL_STATE(3512)] = 154006, + [SMALL_STATE(3513)] = 154029, + [SMALL_STATE(3514)] = 154052, + [SMALL_STATE(3515)] = 154075, + [SMALL_STATE(3516)] = 154098, + [SMALL_STATE(3517)] = 154121, + [SMALL_STATE(3518)] = 154144, + [SMALL_STATE(3519)] = 154167, + [SMALL_STATE(3520)] = 154190, + [SMALL_STATE(3521)] = 154213, + [SMALL_STATE(3522)] = 154236, + [SMALL_STATE(3523)] = 154259, + [SMALL_STATE(3524)] = 154282, + [SMALL_STATE(3525)] = 154305, + [SMALL_STATE(3526)] = 154328, + [SMALL_STATE(3527)] = 154351, + [SMALL_STATE(3528)] = 154374, + [SMALL_STATE(3529)] = 154397, + [SMALL_STATE(3530)] = 154420, + [SMALL_STATE(3531)] = 154443, + [SMALL_STATE(3532)] = 154466, + [SMALL_STATE(3533)] = 154489, + [SMALL_STATE(3534)] = 154512, + [SMALL_STATE(3535)] = 154535, + [SMALL_STATE(3536)] = 154558, + [SMALL_STATE(3537)] = 154581, + [SMALL_STATE(3538)] = 154604, + [SMALL_STATE(3539)] = 154627, + [SMALL_STATE(3540)] = 154650, + [SMALL_STATE(3541)] = 154673, + [SMALL_STATE(3542)] = 154696, + [SMALL_STATE(3543)] = 154719, + [SMALL_STATE(3544)] = 154742, + [SMALL_STATE(3545)] = 154765, + [SMALL_STATE(3546)] = 154788, + [SMALL_STATE(3547)] = 154811, + [SMALL_STATE(3548)] = 154834, + [SMALL_STATE(3549)] = 154857, + [SMALL_STATE(3550)] = 154880, + [SMALL_STATE(3551)] = 154903, + [SMALL_STATE(3552)] = 154926, + [SMALL_STATE(3553)] = 154949, + [SMALL_STATE(3554)] = 154972, + [SMALL_STATE(3555)] = 154995, + [SMALL_STATE(3556)] = 155018, + [SMALL_STATE(3557)] = 155041, + [SMALL_STATE(3558)] = 155064, + [SMALL_STATE(3559)] = 155087, + [SMALL_STATE(3560)] = 155110, + [SMALL_STATE(3561)] = 155133, + [SMALL_STATE(3562)] = 155156, + [SMALL_STATE(3563)] = 155179, + [SMALL_STATE(3564)] = 155202, + [SMALL_STATE(3565)] = 155225, + [SMALL_STATE(3566)] = 155248, + [SMALL_STATE(3567)] = 155271, + [SMALL_STATE(3568)] = 155294, + [SMALL_STATE(3569)] = 155317, + [SMALL_STATE(3570)] = 155340, + [SMALL_STATE(3571)] = 155363, + [SMALL_STATE(3572)] = 155386, + [SMALL_STATE(3573)] = 155409, + [SMALL_STATE(3574)] = 155432, + [SMALL_STATE(3575)] = 155455, + [SMALL_STATE(3576)] = 155478, + [SMALL_STATE(3577)] = 155501, + [SMALL_STATE(3578)] = 155524, + [SMALL_STATE(3579)] = 155547, + [SMALL_STATE(3580)] = 155570, + [SMALL_STATE(3581)] = 155593, + [SMALL_STATE(3582)] = 155616, + [SMALL_STATE(3583)] = 155639, + [SMALL_STATE(3584)] = 155662, + [SMALL_STATE(3585)] = 155685, + [SMALL_STATE(3586)] = 155708, + [SMALL_STATE(3587)] = 155731, + [SMALL_STATE(3588)] = 155754, + [SMALL_STATE(3589)] = 155777, + [SMALL_STATE(3590)] = 155800, + [SMALL_STATE(3591)] = 155823, + [SMALL_STATE(3592)] = 155846, + [SMALL_STATE(3593)] = 155869, + [SMALL_STATE(3594)] = 155892, + [SMALL_STATE(3595)] = 155915, + [SMALL_STATE(3596)] = 155938, + [SMALL_STATE(3597)] = 155961, + [SMALL_STATE(3598)] = 155984, + [SMALL_STATE(3599)] = 156007, + [SMALL_STATE(3600)] = 156030, + [SMALL_STATE(3601)] = 156053, + [SMALL_STATE(3602)] = 156076, + [SMALL_STATE(3603)] = 156099, + [SMALL_STATE(3604)] = 156122, + [SMALL_STATE(3605)] = 156145, + [SMALL_STATE(3606)] = 156168, + [SMALL_STATE(3607)] = 156191, + [SMALL_STATE(3608)] = 156214, + [SMALL_STATE(3609)] = 156237, + [SMALL_STATE(3610)] = 156260, + [SMALL_STATE(3611)] = 156283, + [SMALL_STATE(3612)] = 156306, + [SMALL_STATE(3613)] = 156329, + [SMALL_STATE(3614)] = 156352, + [SMALL_STATE(3615)] = 156375, + [SMALL_STATE(3616)] = 156398, + [SMALL_STATE(3617)] = 156421, + [SMALL_STATE(3618)] = 156444, + [SMALL_STATE(3619)] = 156467, + [SMALL_STATE(3620)] = 156490, + [SMALL_STATE(3621)] = 156513, + [SMALL_STATE(3622)] = 156536, + [SMALL_STATE(3623)] = 156559, + [SMALL_STATE(3624)] = 156582, + [SMALL_STATE(3625)] = 156605, + [SMALL_STATE(3626)] = 156628, + [SMALL_STATE(3627)] = 156651, + [SMALL_STATE(3628)] = 156674, + [SMALL_STATE(3629)] = 156697, + [SMALL_STATE(3630)] = 156720, + [SMALL_STATE(3631)] = 156743, + [SMALL_STATE(3632)] = 156766, + [SMALL_STATE(3633)] = 156789, + [SMALL_STATE(3634)] = 156812, + [SMALL_STATE(3635)] = 156835, + [SMALL_STATE(3636)] = 156839, + [SMALL_STATE(3637)] = 156843, + [SMALL_STATE(3638)] = 156847, + [SMALL_STATE(3639)] = 156851, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3401), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3633), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3332), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3635), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3638), + [13] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 0, 0, 0), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2123), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1838), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3262), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1912), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3547), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2600), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3392), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3337), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2566), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1920), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2249), + [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3587), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3298), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1829), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2355), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1661), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2307), + [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2344), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3625), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3086), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2481), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3491), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3163), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2325), + [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2697), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2024), + [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2511), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2194), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(484), + [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3444), + [75] = {.entry = {.count = 1, .reusable = false}}, SHIFT(994), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(994), + [79] = {.entry = {.count = 1, .reusable = false}}, SHIFT(995), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(996), + [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2218), + [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2219), + [87] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2181), + [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2189), + [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2326), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2334), + [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2246), + [97] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2264), + [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(998), + [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206), + [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1825), + [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1336), + [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), + [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1372), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378), + [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3310), + [127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), + [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3315), + [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3044), + [133] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3150), + [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3617), + [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3176), + [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3082), + [145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2239), + [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2940), + [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3260), + [151] = {.entry = {.count = 1, .reusable = false}}, SHIFT(918), + [153] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2346), + [155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(984), + [157] = {.entry = {.count = 1, .reusable = false}}, SHIFT(985), + [159] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2191), + [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1827), + [163] = {.entry = {.count = 1, .reusable = false}}, SHIFT(979), + [165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1179), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [173] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_switch_statement_case, 3, 0, 0), SHIFT(484), + [176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [178] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_case, 3, 0, 0), + [180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), + [182] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_statement_case, 3, 0, 0), + [184] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3540), + [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3077), + [188] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_switch_statement_case, 5, 0, 0), SHIFT(484), + [191] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_case, 5, 0, 0), + [193] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_statement_case, 5, 0, 0), + [195] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(484), + [198] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3444), + [201] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(994), + [204] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(994), + [207] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(995), + [210] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(996), + [213] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2218), + [216] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2219), + [219] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2181), + [222] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2189), + [225] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2326), + [228] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2334), + [231] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2246), + [234] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2264), + [237] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2), + [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), + [242] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(52), + [245] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(998), + [248] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(30), + [251] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(206), + [254] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1825), + [257] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(453), + [260] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1336), + [263] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1085), + [266] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1372), + [269] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(380), + [272] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3310), + [275] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), + [277] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(31), + [280] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3315), + [283] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3044), + [286] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(197), + [289] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(186), + [292] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3150), + [295] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3540), + [298] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3077), + [301] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3082), + [304] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2239), + [307] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1920), + [310] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2249), + [313] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2940), + [316] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3260), + [319] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(918), + [322] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2346), + [325] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1661), + [328] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(984), + [331] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(985), + [334] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2191), + [337] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1827), + [340] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(2511), + [343] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(979), + [346] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1179), + [349] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_switch_statement_case, 4, 0, 0), SHIFT(484), + [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_case, 4, 0, 0), + [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_statement_case, 4, 0, 0), + [356] = {.entry = {.count = 1, .reusable = false}}, SHIFT(517), + [358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1211), + [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [366] = {.entry = {.count = 1, .reusable = false}}, SHIFT(620), + [368] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1354), + [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1354), + [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1291), + [376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1085), + [378] = {.entry = {.count = 1, .reusable = false}}, SHIFT(379), + [380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3066), + [382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3391), + [384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3212), + [386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1831), + [388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), + [392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1117), + [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444), + [396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_default, 2, 0, 0), + [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_default, 3, 0, 0), + [400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement_default, 4, 0, 0), + [402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(492), + [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), + [406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), + [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [416] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), + [418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432), + [424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2073), + [426] = {.entry = {.count = 1, .reusable = false}}, SHIFT(384), + [428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [430] = {.entry = {.count = 1, .reusable = false}}, SHIFT(377), + [432] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3235), + [434] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3630), + [436] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3236), + [438] = {.entry = {.count = 1, .reusable = false}}, SHIFT(515), + [440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2034), + [444] = {.entry = {.count = 1, .reusable = false}}, SHIFT(516), + [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), + [450] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2158), + [452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), + [454] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), + [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), + [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1937), + [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1221), + [464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(838), + [466] = {.entry = {.count = 1, .reusable = false}}, SHIFT(509), + [468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rest_pattern, 1, 0, 0), + [474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [476] = {.entry = {.count = 1, .reusable = false}}, SHIFT(651), + [478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), + [480] = {.entry = {.count = 1, .reusable = false}}, SHIFT(656), + [482] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1941), + [484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2053), + [486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3101), + [488] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), + [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [494] = {.entry = {.count = 1, .reusable = false}}, SHIFT(642), + [496] = {.entry = {.count = 1, .reusable = false}}, SHIFT(677), + [498] = {.entry = {.count = 1, .reusable = false}}, SHIFT(536), + [500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), + [502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), + [506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), + [512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(974), + [514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), + [516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1259), + [518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), + [520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2130), + [522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), + [524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(980), + [526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), + [530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1268), + [534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2143), + [538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), + [540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2148), + [542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2394), + [544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2406), + [546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), + [548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1004), + [550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2386), + [554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2387), + [556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2448), + [558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2453), + [560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1303), + [562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2381), + [564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(945), + [566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2396), + [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2397), + [570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2402), + [572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2403), + [574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1284), + [576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), + [578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), + [582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), + [584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), + [588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), + [590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1241), + [596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), + [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), + [602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), + [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1165), + [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), + [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1183), + [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), + [612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1198), + [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), + [618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2380), + [624] = {.entry = {.count = 1, .reusable = false}}, SHIFT(681), + [626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(599), + [628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), + [630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1255), + [632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1108), + [634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), + [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), + [640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2149), + [642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), + [644] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__argument_list, 2, 0, 0), + [646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__argument_list, 3, 0, 0), + [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2072), + [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2032), + [652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 1, 0, 0), + [654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), + [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2382), + [658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__map_pattern_entry, 1, 0, 0), + [660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2043), + [662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2069), + [664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(947), + [666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 2, 0, 57), + [670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 88), + [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 105), + [674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 2, 0, 0), + [676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 77), + [678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 79), + [680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2405), + [682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 2, 0, 59), + [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 91), + [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 59), + [690] = {.entry = {.count = 1, .reusable = false}}, SHIFT(233), + [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(454), + [694] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1333), + [696] = {.entry = {.count = 1, .reusable = false}}, SHIFT(382), + [698] = {.entry = {.count = 1, .reusable = false}}, SHIFT(605), + [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3345), + [702] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1093), + [704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), + [706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1094), + [708] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1095), + [710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2212), + [712] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2236), + [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2193), + [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2200), + [718] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2329), + [720] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2330), + [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2237), + [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2238), + [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [730] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1097), + [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [734] = {.entry = {.count = 1, .reusable = false}}, SHIFT(214), + [736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(451), + [738] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1337), + [740] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [742] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3323), + [744] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1132), + [746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1123), + [748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1124), + [750] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1949), + [752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1130), + [754] = {.entry = {.count = 1, .reusable = false}}, SHIFT(241), + [756] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2415), + [758] = {.entry = {.count = 1, .reusable = false}}, SHIFT(249), + [760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1288), + [762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(606), + [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [770] = {.entry = {.count = 1, .reusable = false}}, SHIFT(281), + [772] = {.entry = {.count = 1, .reusable = false}}, SHIFT(652), + [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3531), + [776] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1253), + [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1253), + [780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1258), + [782] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), + [784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2262), + [786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2263), + [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2177), + [790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2179), + [792] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2317), + [794] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2318), + [796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2265), + [798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2266), + [800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [804] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1283), + [806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [808] = {.entry = {.count = 1, .reusable = false}}, SHIFT(305), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), + [812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1334), + [814] = {.entry = {.count = 1, .reusable = false}}, SHIFT(397), + [816] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3322), + [818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1245), + [820] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1230), + [822] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1944), + [824] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1264), + [826] = {.entry = {.count = 1, .reusable = false}}, SHIFT(525), + [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [834] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), + [836] = {.entry = {.count = 1, .reusable = false}}, SHIFT(277), + [838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(452), + [840] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1324), + [842] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), + [844] = {.entry = {.count = 1, .reusable = false}}, SHIFT(301), + [846] = {.entry = {.count = 1, .reusable = false}}, SHIFT(303), + [848] = {.entry = {.count = 1, .reusable = false}}, SHIFT(284), + [850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(306), + [852] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), + [854] = {.entry = {.count = 1, .reusable = false}}, SHIFT(820), + [856] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1138), + [858] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1015), + [860] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(1936), + [863] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(3467), + [866] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2133), + [869] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2133), + [872] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2134), + [875] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2135), + [878] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2272), + [881] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2273), + [884] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2209), + [887] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2198), + [890] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2331), + [893] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2332), + [896] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2275), + [899] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2276), + [902] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(174), + [905] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(394), + [908] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2136), + [911] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), SHIFT(376), + [914] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), + [916] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(748), + [919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2, 0, 0), + [921] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(2689), + [924] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_label, 2, 0, 0), SHIFT(1953), + [927] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2068), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3467), + [931] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2133), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2133), + [935] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2134), + [937] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2135), + [939] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2272), + [941] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2273), + [943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2209), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2198), + [947] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2331), + [949] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2332), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2275), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2276), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), + [961] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2136), + [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), + [965] = {.entry = {.count = 1, .reusable = false}}, SHIFT(748), + [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2689), + [969] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3498), + [971] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1436), + [973] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1953), + [975] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2078), + [977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [979] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3244), + [981] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3091), + [983] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3145), + [985] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3304), + [987] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1936), + [989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2047), + [991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), + [993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2038), + [995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2051), + [997] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), + [999] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), + [1001] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), REDUCE(sym_block, 2, 0, 0), + [1004] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_pattern, 2, 0, 0), + [1006] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), + [1008] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), + [1010] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), REDUCE(sym_block, 2, 0, 0), + [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2044), + [1015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2056), + [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1239), + [1019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2080), + [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2063), + [1023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2400), + [1025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2061), + [1027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2045), + [1029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [1031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2029), + [1033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2062), + [1035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1197), + [1037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), + [1039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [1041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1200), + [1043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2395), + [1045] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 1, 0, 0), + [1047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 2, 0, 0), + [1049] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 3, 0, 0), + [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), + [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), + [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__semicolon, 1, 0, 0), + [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__semicolon, 1, 0, 0), + [1059] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_body, 2, 0, 0), + [1061] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_body, 2, 0, 0), + [1063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_body, 1, 0, 0), + [1065] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_body, 1, 0, 0), + [1067] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_body, 4, 0, 0), + [1069] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_body, 4, 0, 0), + [1071] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_body, 3, 0, 0), + [1073] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_body, 3, 0, 0), + [1075] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1224), + [1077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3355), + [1079] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2364), + [1081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2364), + [1083] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2366), + [1085] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2388), + [1087] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2251), + [1089] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2288), + [1091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2205), + [1093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2199), + [1095] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2297), + [1097] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2298), + [1099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2253), + [1101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2254), + [1103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [1105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [1107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2404), + [1109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [1111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3321), + [1113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1939), + [1115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2432), + [1117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1052), + [1119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1050), + [1121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(991), + [1123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(893), + [1125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 4, 0, 0), + [1127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_section, 3, 0, 0), + [1129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1281), + [1131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), + [1133] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_section, 3, 0, 0), + [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_section, 2, 0, 0), + [1137] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_section, 2, 0, 0), + [1139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 5, 0, 0), + [1141] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_try_statement, 1, 0, 8), + [1143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_try_statement, 1, 0, 8), + [1145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2086), + [1147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3309), + [1149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3084), + [1151] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_try_statement, 2, 0, 8), + [1153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_try_statement, 2, 0, 8), + [1155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_section, 4, 0, 0), + [1157] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_section, 4, 0, 0), + [1159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_try_statement_repeat1, 2, 0, 0), + [1161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_try_statement_repeat1, 2, 0, 0), + [1163] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_try_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(2086), + [1166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_try_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(3309), + [1169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), + [1171] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2123), + [1174] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(1838), + [1177] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3082), + [1180] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3547), + [1183] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2600), + [1186] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3392), + [1189] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3337), + [1192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2566), + [1195] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(1920), + [1198] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2249), + [1201] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(1661), + [1204] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2307), + [1207] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3625), + [1210] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3086), + [1213] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2481), + [1216] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3491), + [1219] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(3163), + [1222] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2325), + [1225] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2697), + [1228] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2024), + [1231] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2511), + [1234] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 2, 0, 0), SHIFT_REPEAT(2194), + [1237] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2218), + [1240] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2219), + [1243] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2181), + [1246] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2189), + [1249] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2326), + [1252] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2334), + [1255] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2246), + [1258] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2264), + [1261] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), + [1263] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), + [1265] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_literal, 1, 0, 0), + [1267] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_literal, 1, 0, 0), + [1269] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_program, 6, 0, 0), + [1271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), + [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [1275] = {.entry = {.count = 1, .reusable = false}}, SHIFT(291), + [1277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [1279] = {.entry = {.count = 1, .reusable = false}}, SHIFT(330), + [1281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [1283] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), + [1285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1357), + [1287] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1357), + [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [1291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), + [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2540), + [1295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2700), + [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), SHIFT(2482), + [1300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [1302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1374), + [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), + [1306] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(269), + [1309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), + [1311] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3225), + [1314] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3445), + [1317] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3446), + [1320] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_name, 1, 0, 1), + [1322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), + [1324] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), SHIFT(706), + [1328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignable_expression, 1, 0, 0), + [1330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignable_expression, 1, 0, 0), + [1332] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), + [1334] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), + [1337] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), SHIFT(2337), + [1341] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), SHIFT(3393), + [1345] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__on_part, 4, 0, 0), + [1347] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__on_part, 4, 0, 0), + [1349] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__try_head, 2, 0, 20), + [1351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__try_head, 2, 0, 20), + [1353] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__on_part, 3, 0, 0), + [1355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__on_part, 3, 0, 0), + [1357] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__on_part, 2, 0, 0), + [1359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__on_part, 2, 0, 0), + [1361] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_try_statement_repeat1, 1, 0, 0), + [1363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_try_statement_repeat1, 1, 0, 0), + [1365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__cascade_subsection, 2, 0, 0), + [1367] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 2, 0, 0), SHIFT(161), + [1370] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__cascade_subsection, 2, 0, 0), + [1372] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__cascade_subsection, 2, 0, 0), SHIFT(2028), + [1375] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__cascade_subsection, 1, 0, 0), + [1377] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 1, 0, 0), SHIFT(161), + [1380] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__cascade_subsection, 1, 0, 0), + [1382] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__cascade_subsection, 1, 0, 0), SHIFT(2028), + [1385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_logical_and_expression_repeat1, 2, 0, 0), + [1387] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_logical_and_expression_repeat1, 2, 0, 0), + [1389] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_logical_or_expression_repeat1, 2, 0, 0), + [1391] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_logical_or_expression_repeat1, 2, 0, 0), + [1393] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_additive_expression_repeat1, 2, 0, 0), + [1395] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_additive_expression_repeat1, 2, 0, 0), + [1397] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_without_cascade, 1, 0, 0), + [1399] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_without_cascade, 1, 0, 0), + [1401] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), + [1403] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 3, 0, 0), + [1405] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(329), + [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_shift_expression_repeat1, 2, 0, 0), + [1410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_shift_expression_repeat1, 2, 0, 0), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), + [1414] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), + [1416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), + [1418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 38), + [1422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__if_null_expression, 2, 0, 38), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), + [1426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relational_expression, 3, 0, 0), + [1430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_relational_expression, 3, 0, 0), + [1432] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_relational_expression, 3, 0, 0), SHIFT(1354), + [1435] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_relational_expression, 3, 0, 0), SHIFT(1354), + [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), + [1440] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), SHIFT_REPEAT(161), + [1443] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), + [1445] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), SHIFT_REPEAT(2028), + [1448] = {.entry = {.count = 4, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [1453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [1455] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), + [1459] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), + [1462] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), + [1465] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), + [1470] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(205), + [1473] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3231), + [1476] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3464), + [1479] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3465), + [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1484] = {.entry = {.count = 1, .reusable = false}}, SHIFT(300), + [1486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362), + [1488] = {.entry = {.count = 1, .reusable = false}}, SHIFT(363), + [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [1492] = {.entry = {.count = 1, .reusable = false}}, SHIFT(365), + [1494] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2700), + [1496] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), SHIFT(2496), + [1499] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local_variable_declaration, 3, 0, 0), + [1501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_variable_declaration, 3, 0, 0), + [1503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local_variable_declaration, 2, 0, 0), + [1505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_variable_declaration, 2, 0, 0), + [1507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2482), + [1509] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [1513] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_assignable_expression, 1, 0, 0), REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [1516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 5, 0, 71), + [1518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 5, 0, 71), + [1520] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_clause, 2, 0, 0), + [1522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_clause, 2, 0, 0), + [1524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_try_statement, 3, 0, 8), + [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_try_statement, 3, 0, 8), + [1528] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local_function_declaration, 1, 0, 0), + [1530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_function_declaration, 1, 0, 0), + [1532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assert_statement, 2, 0, 0), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assert_statement, 2, 0, 0), + [1536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_local_function_declaration, 2, 0, 0), + [1538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_local_function_declaration, 2, 0, 0), + [1540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 7, 0, 101), + [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 7, 0, 101), + [1544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 7, 0, 102), + [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 7, 0, 102), + [1548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), + [1550] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, 1, 0), + [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, 1, 0), + [1554] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, 0, 0), + [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, 0, 0), + [1558] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 2, 0, 22), + [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 2, 0, 22), + [1562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 9, 0, 113), + [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 9, 0, 113), + [1566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, 2, 0), + [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, 2, 0), + [1570] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1923), + [1572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3494), + [1574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2561), + [1576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3293), + [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1826), + [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2018), + [1582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_block, 4, 0, 0), + [1584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_block, 4, 0, 0), + [1586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 3, 0, 37), + [1588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 3, 0, 37), + [1590] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), + [1593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_continue_statement, 2, 0, 0), + [1595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_continue_statement, 2, 0, 0), + [1597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2, 0, 0), + [1599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2, 0, 0), + [1601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 4, 0, 56), + [1603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 4, 0, 56), + [1605] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_block, 2, 0, 0), + [1607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_block, 2, 0, 0), + [1609] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_each_statement, 4, 0, 0), + [1611] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_each_statement, 4, 0, 0), + [1613] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_break_statement, 2, 0, 0), + [1615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_break_statement, 2, 0, 0), + [1617] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 2, 0, 0), + [1619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 2, 0, 0), + [1621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 72), + [1623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 72), + [1625] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [1627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_statement, 3, 0, 36), + [1629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_statement, 3, 0, 36), + [1631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 3, 0, 36), + [1633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 3, 0, 36), + [1635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_continue_statement, 3, 0, 0), + [1637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_continue_statement, 3, 0, 0), + [1639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_statement, 3, 0, 0), + [1641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_statement, 3, 0, 0), + [1643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 3, 0, 0), + [1645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 3, 0, 0), + [1647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_block, 3, 0, 0), + [1649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_block, 3, 0, 0), + [1651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_break_statement, 3, 0, 0), + [1653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_break_statement, 3, 0, 0), + [1655] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__assignable_selector, 1, 0, 0), + [1657] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__assignable_selector, 1, 0, 0), + [1659] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_block_repeat1, 1, 0, 0), + [1661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_block_repeat1, 1, 0, 0), + [1663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional_assignable_selector, 2, 0, 0), + [1665] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_conditional_assignable_selector, 2, 0, 0), + [1667] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), + [1669] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), + [1671] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), SHIFT_REPEAT(169), + [1674] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 2, 0, 0), SHIFT(169), + [1677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unconditional_assignable_selector, 1, 0, 0), + [1679] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unconditional_assignable_selector, 1, 0, 0), + [1681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_selector, 1, 0, 0), + [1683] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__assignable_selector_part, 2, 0, 0), + [1685] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__assignable_selector_part, 2, 0, 0), + [1687] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_selector, 1, 0, 0), + [1689] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 1, 0, 0), SHIFT(169), + [1692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__primary, 2, 0, 0), + [1694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignable_expression, 2, 0, 0), + [1696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignable_expression, 2, 0, 0), + [1698] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__primary, 2, 0, 0), + [1700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(362), + [1703] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [1705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [1707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_selector, 3, 0, 0), + [1709] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_selector, 3, 0, 0), + [1711] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__assignable_selector_part, 1, 0, 0), + [1713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__assignable_selector_part, 1, 0, 0), + [1715] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2064), + [1717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), + [1719] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3502), + [1721] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1916), + [1723] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2180), + [1725] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2632), + [1727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1752), + [1729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1774), + [1731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_part, 1, 0, 0), + [1733] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_argument_part, 1, 0, 0), + [1735] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2064), + [1738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), + [1740] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(1838), + [1743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(3082), + [1746] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2239), + [1749] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(1920), + [1752] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2249), + [1755] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2346), + [1758] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(3502), + [1761] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(1661), + [1764] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2307), + [1767] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(1916), + [1770] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2325), + [1773] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2180), + [1776] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2632), + [1779] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2511), + [1782] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2194), + [1785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_selector, 1, 0, 0), + [1787] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_selector, 1, 0, 0), + [1789] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2064), + [1792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), + [1794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(1838), + [1797] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(3082), + [1800] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2239), + [1803] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(1920), + [1806] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2249), + [1809] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2346), + [1812] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(3502), + [1815] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(1661), + [1818] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2307), + [1821] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(1916), + [1824] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2325), + [1827] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2180), + [1830] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2632), + [1833] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2511), + [1836] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), SHIFT_REPEAT(2194), + [1839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat2, 1, 0, 0), + [1841] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 1, 0, 0), + [1843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat1, 1, 0, 0), + [1845] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat1, 1, 0, 0), + [1847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_selector, 2, 0, 0), + [1849] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_selector, 2, 0, 0), + [1851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1786), + [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_part, 2, 0, 0), + [1855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_argument_part, 2, 0, 0), + [1857] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2212), + [1860] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2236), + [1863] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2193), + [1866] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2200), + [1869] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2329), + [1872] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2330), + [1875] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2237), + [1878] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2238), + [1881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1791), + [1883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1815), + [1885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1739), + [1887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [1889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 2, 0, 0), + [1891] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 2, 0, 0), + [1893] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_arguments, 3, 0, 0), + [1895] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_arguments, 3, 0, 0), + [1897] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop_parts, 3, 0, 58), + [1899] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop_parts, 3, 0, 58), + [1901] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_double_quotes, 3, 0, 0), + [1903] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_double_quotes, 3, 0, 0), + [1905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_single_quotes_multiple, 3, 0, 0), + [1907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_single_quotes_multiple, 3, 0, 0), + [1909] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), REDUCE(sym_super_formal_parameter, 3, 0, 0), + [1912] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), SHIFT(706), + [1915] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), REDUCE(sym_super_formal_parameter, 3, 0, 0), + [1918] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_unconditional_assignable_selector, 2, 0, 0), SHIFT(2337), + [1921] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_double_quotes_multiple, 2, 0, 0), + [1923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_double_quotes_multiple, 2, 0, 0), + [1925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_single_quotes_multiple, 2, 0, 0), + [1927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_single_quotes_multiple, 2, 0, 0), + [1929] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_relational_operator, 1, 0, 0), SHIFT(2204), + [1932] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relational_operator, 1, 0, 0), + [1934] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_relational_operator, 1, 0, 0), + [1936] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_relational_operator, 1, 0, 0), SHIFT(1838), + [1939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1566), + [1941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [1943] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 1, 0, 0), + [1945] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 1, 0, 0), + [1947] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_double_quotes, 2, 0, 0), + [1949] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_double_quotes, 2, 0, 0), + [1951] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_single_quotes, 2, 0, 0), + [1953] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_single_quotes, 2, 0, 0), + [1955] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_double_quotes_multiple, 2, 0, 0), + [1957] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_double_quotes_multiple, 2, 0, 0), + [1959] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_single_quotes_multiple, 2, 0, 0), + [1961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_single_quotes_multiple, 2, 0, 0), + [1963] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_double_quotes, 2, 0, 0), + [1965] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_double_quotes, 2, 0, 0), + [1967] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_single_quotes, 2, 0, 0), + [1969] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_single_quotes, 2, 0, 0), + [1971] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2262), + [1974] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2263), + [1977] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2177), + [1980] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2179), + [1983] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2317), + [1986] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2318), + [1989] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2265), + [1992] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2266), + [1995] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_double_quotes, 3, 0, 0), + [1997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_double_quotes, 3, 0, 0), + [1999] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_single_quotes, 3, 0, 0), + [2001] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_single_quotes, 3, 0, 0), + [2003] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_double_quotes_multiple, 3, 0, 0), + [2005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_double_quotes_multiple, 3, 0, 0), + [2007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal_single_quotes_multiple, 3, 0, 0), + [2009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal_single_quotes_multiple, 3, 0, 0), + [2011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_single_quotes, 3, 0, 0), + [2013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_single_quotes, 3, 0, 0), + [2015] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__raw_string_literal_double_quotes_multiple, 3, 0, 0), + [2017] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__raw_string_literal_double_quotes_multiple, 3, 0, 0), + [2019] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), + [2021] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(260), + [2024] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(166), + [2027] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3094), + [2030] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(2065), + [2033] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), + [2035] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(988), + [2038] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3470), + [2041] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3475), + [2044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_name, 1, 0, 1), + [2046] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_postfix_expression, 1, 0, 0), + [2048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [2050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [2052] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3067), + [2054] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2065), + [2056] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_postfix_expression, 1, 0, 0), + [2058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(988), + [2060] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3522), + [2062] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3524), + [2064] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(273), + [2067] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3067), + [2070] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3522), + [2073] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3524), + [2076] = {.entry = {.count = 1, .reusable = false}}, SHIFT(245), + [2078] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), SHIFT(3393), + [2082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2084] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3094), + [2086] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3470), + [2088] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3475), + [2090] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), + [2092] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(260), + [2095] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(166), + [2098] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3094), + [2101] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(2065), + [2104] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), + [2106] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(988), + [2109] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3470), + [2112] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3475), + [2115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_postfix_expression, 2, 0, 0), + [2117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_postfix_expression, 2, 0, 0), + [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), + [2121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(256), + [2124] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(166), + [2127] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3183), + [2130] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(2065), + [2133] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), + [2135] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(988), + [2138] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3326), + [2141] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3327), + [2144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [2146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(283), + [2148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349), + [2150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(350), + [2152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353), + [2154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(347), + [2156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2470), + [2158] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(273), + [2161] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3067), + [2164] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3522), + [2167] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3524), + [2170] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 3, 0, 0), + [2172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [2174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(298), + [2176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), + [2178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [2180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), + [2182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(346), + [2184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2529), + [2186] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_initializer, 3, 0, 0), + [2188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [2190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [2192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3230), + [2195] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(2058), + [2198] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1131), + [2200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3460), + [2202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3461), + [2204] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(270), + [2207] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(167), + [2210] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3226), + [2213] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(1131), + [2216] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3450), + [2219] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3451), + [2222] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(272), + [2225] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3460), + [2228] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3461), + [2231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [2233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3226), + [2235] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2058), + [2237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3450), + [2239] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3451), + [2241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 5, 0, 0), + [2243] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_initializer, 5, 0, 0), + [2245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3230), + [2247] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(349), + [2250] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(272), + [2253] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(167), + [2256] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3230), + [2259] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(2058), + [2262] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(1131), + [2265] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3460), + [2268] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3461), + [2271] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1909), + [2273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), + [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(894), + [2277] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2009), + [2279] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(270), + [2282] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3226), + [2285] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3450), + [2288] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3451), + [2291] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(271), + [2294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(167), + [2297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3228), + [2300] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(2058), + [2303] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(1131), + [2306] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3455), + [2309] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3456), + [2312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [2314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [2316] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3202), + [2319] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(2042), + [2322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1285), + [2324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3365), + [2326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3366), + [2328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3202), + [2330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2042), + [2332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [2334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), + [2336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [2338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(318), + [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [2342] = {.entry = {.count = 1, .reusable = false}}, SHIFT(320), + [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2471), + [2346] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(342), + [2349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [2351] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 1, 0, 0), SHIFT(3154), + [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3525), + [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3528), + [2358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3154), + [2360] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3154), + [2363] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(2042), + [2366] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__postfix_expression, 2, 0, 0), SHIFT(3202), + [2369] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(267), + [2372] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(163), + [2375] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3219), + [2378] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(2042), + [2381] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(1285), + [2384] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3426), + [2387] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3427), + [2390] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_relational_operator, 1, 0, 0), SHIFT(1662), + [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), + [2395] = {.entry = {.count = 1, .reusable = false}}, SHIFT(286), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), + [2399] = {.entry = {.count = 1, .reusable = false}}, SHIFT(358), + [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [2403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(360), + [2405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 1, 0, 0), + [2407] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 1, 0, 0), + [2409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [2411] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), + [2414] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1697), + [2418] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(859), + [2422] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2353), + [2426] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), + [2429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_type_tail, 1, 0, 0), + [2431] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1697), + [2434] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(859), + [2437] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2353), + [2440] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), + [2442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3616), + [2444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__relational_pattern, 2, 0, 0), + [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3485), + [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [2450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [2452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3214), + [2454] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2028), + [2456] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3403), + [2458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3404), + [2460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 2, 0, 0), + [2462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 2, 0, 0), + [2464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), + [2466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), + [2468] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(856), + [2471] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(357), + [2474] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_equality_expression, 3, 0, 0), SHIFT(317), + [2477] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__real_expression, 1, 0, 0), + [2479] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__real_expression, 1, 0, 0), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), + [2483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1350), + [2485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), + [2487] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(859), + [2490] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(2065), + [2493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), + [2495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_type_tail, 2, 0, 0), + [2497] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1697), + [2500] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(859), + [2503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), + [2505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_type_tail, 3, 0, 0), + [2507] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1697), + [2510] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(859), + [2513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), + [2515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shift_expression, 2, 0, 0), + [2517] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shift_expression, 2, 0, 0), + [2519] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_shift_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1357), + [2522] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_shift_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1357), + [2525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 2, 0, 0), + [2527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 2, 0, 0), + [2529] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), + [2532] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1697), + [2536] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(859), + [2540] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), + [2543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_multiplicative_expression_repeat1, 2, 0, 0), + [2545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_multiplicative_expression_repeat1, 2, 0, 0), + [2547] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_multiplicative_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1350), + [2550] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_multiplicative_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1350), + [2553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_type_tail, 4, 0, 0), + [2555] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(859), + [2558] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), + [2560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 2, 0, 0), + [2562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 2, 0, 0), + [2564] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_logical_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), + [2567] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), + [2569] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), + [2571] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), SHIFT_REPEAT(2482), + [2574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void, 1, 0, 0), + [2576] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), SHIFT(859), + [2579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), + [2581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_function, 1, 0, 0), + [2583] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_name, 1, 0, 1), SHIFT(3405), + [2586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), + [2588] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), SHIFT(859), + [2591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), + [2593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 2, 0, 0), + [2595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 2, 0, 0), + [2597] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 2, 0, 0), SHIFT(2482), + [2600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3342), + [2602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3634), + [2604] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_additive_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), + [2607] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_logical_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1374), + [2610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 2, 0, 0), + [2612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 2, 0, 0), + [2614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_expression, 2, 0, 0), + [2616] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_expression, 2, 0, 0), + [2618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 1, 0, 0), + [2620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__function_type_tails, 1, 0, 0), + [2622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 3, 0, 0), + [2624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_pattern, 3, 0, 0), + [2626] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 3, 0, 0), + [2628] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), + [2630] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_pattern, 3, 0, 0), + [2632] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), + [2634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_tearoff, 3, 0, 0), + [2636] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constructor_tearoff, 3, 0, 0), + [2638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_null_expression, 2, 0, 21), + [2640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_null_expression, 2, 0, 21), + [2642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bitwise_or_expression, 2, 0, 0), + [2644] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bitwise_or_expression, 2, 0, 0), + [2646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bitwise_xor_expression, 2, 0, 0), + [2648] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bitwise_xor_expression, 2, 0, 0), + [2650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bitwise_and_expression, 2, 0, 0), + [2652] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bitwise_and_expression, 2, 0, 0), + [2654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), + [2656] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(327), + [2659] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), + [2661] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(330), + [2664] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(331), + [2667] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(332), + [2670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_builtin_identifier, 1, 0, 0), + [2672] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_builtin_identifier, 1, 0, 0), + [2674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 2, 0, 0), + [2676] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 2, 0, 0), + [2678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_name, 2, 0, 1), + [2680] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_name, 2, 0, 1), + [2682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nullable_type, 1, 0, 0), + [2684] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nullable_type, 1, 0, 0), + [2686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [2688] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 3, 0, 0), + [2690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_dot_identifier, 2, 0, 7), + [2692] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_dot_identifier, 2, 0, 7), + [2694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 4, 0, 0), + [2696] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_arguments, 4, 0, 0), + [2698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_type_list, 2, 0, 0), + [2700] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_type_list, 2, 0, 0), + [2702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 4, 0, 0), + [2704] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 4, 0, 0), + [2706] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameters, 3, 0, 0), + [2708] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_parameters, 3, 0, 0), + [2710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_type_list, 3, 0, 0), + [2712] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_type_list, 3, 0, 0), + [2714] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 5, 0, 0), + [2716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 5, 0, 0), + [2718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void, 2, 0, 0), + [2720] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_void, 2, 0, 0), + [2722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_function, 2, 0, 0), + [2724] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameters, 4, 0, 0), + [2726] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_parameters, 4, 0, 0), + [2728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_type_list, 4, 0, 0), + [2730] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_type_list, 4, 0, 0), + [2732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_type_tail, 5, 0, 0), + [2734] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_type_tail, 5, 0, 0), + [2736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 6, 0, 0), + [2738] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 6, 0, 0), + [2740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_type_list, 5, 0, 0), + [2742] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_type_list, 5, 0, 0), + [2744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 7, 0, 0), + [2746] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 7, 0, 0), + [2748] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_type_list, 6, 0, 0), + [2750] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parameter_type_list, 6, 0, 0), + [2752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 8, 0, 0), + [2754] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 8, 0, 0), + [2756] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 9, 0, 0), + [2758] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 9, 0, 0), + [2760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 10, 0, 0), + [2762] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 10, 0, 0), + [2764] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat1, 2, 0, 0), SHIFT_REPEAT(165), + [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [2769] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(1060), + [2772] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1716), + [2776] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1067), + [2780] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2358), + [2784] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1716), + [2787] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1067), + [2790] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2358), + [2793] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_assignable_expression, 1, 0, 0), REDUCE(sym__primary, 1, 0, 0), + [2796] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_assignable_expression, 1, 0, 0), REDUCE(sym__primary, 1, 0, 0), + [2799] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym_assignable_expression, 1, 0, 0), REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), + [2803] = {.entry = {.count = 4, .reusable = false}}, REDUCE(sym_assignable_expression, 1, 0, 0), REDUCE(sym__primary, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), SHIFT(3393), + [2808] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 2, 0, 0), + [2810] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_arguments, 2, 0, 0), + [2812] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), + [2814] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2816] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), + [2818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), + [2820] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_arguments, 3, 0, 0), + [2822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 3, 0, 0), + [2824] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 3, 0, 0), + [2826] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 1, 0, 0), + [2828] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 1, 0, 0), + [2830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_const_object_expression, 4, 0, 0), + [2832] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_const_object_expression, 4, 0, 0), + [2834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional_expression, 5, 0, 82), + [2836] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_conditional_expression, 5, 0, 82), + [2838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_expression_without_cascade, 3, 0, 40), + [2840] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_expression_without_cascade, 3, 0, 40), + [2842] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__unary_expression, 1, 0, 0), + [2844] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__unary_expression, 1, 0, 0), + [2846] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 1, 0, 0), + [2848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 1, 0, 0), + [2850] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 0), + [2852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 0), + [2854] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_await_expression, 2, 0, 0), + [2856] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_await_expression, 2, 0, 0), + [2858] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern_assignment, 3, 0, 0), + [2860] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pattern_assignment, 3, 0, 0), + [2862] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_test_expression, 2, 0, 0), + [2864] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_test_expression, 2, 0, 0), + [2866] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_cast_expression, 2, 0, 0), + [2868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_cast_expression, 2, 0, 0), + [2870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rethrow_expression, 1, 0, 0), + [2872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rethrow_expression, 1, 0, 0), + [2874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__literal, 1, 0, 0), + [2876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__literal, 1, 0, 0), + [2878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_invocation, 4, 0, 0), + [2880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constructor_invocation, 4, 0, 0), + [2882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 4, 0, 0), + [2884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 4, 0, 0), + [2886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_tearoff, 4, 0, 0), + [2888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constructor_tearoff, 4, 0, 0), + [2890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression_body, 3, 0, 0), + [2892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression_body, 3, 0, 0), + [2894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 4, 0, 0), + [2896] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 4, 0, 0), + [2898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__primary, 1, 0, 9), + [2900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__primary, 1, 0, 9), + [2902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_postfix_operator, 1, 0, 0), + [2904] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_postfix_operator, 1, 0, 0), + [2906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__bool_literal, 1, 0, 0), + [2908] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__bool_literal, 1, 0, 0), + [2910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), + [2912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), + [2914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 5, 0, 0), + [2916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 5, 0, 0), + [2918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 1, 0, 0), + [2920] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_repeat1, 1, 0, 0), + [2922] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression_body, 1, 0, 0), + [2924] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression_body, 1, 0, 0), + [2926] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__record_literal_no_const, 4, 0, 0), + [2928] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__record_literal_no_const, 4, 0, 0), + [2930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_test, 2, 0, 0), + [2932] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_test, 2, 0, 0), + [2934] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 5, 0, 0), + [2936] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 5, 0, 0), + [2938] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 2, 0, 22), + [2940] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 2, 0, 22), + [2942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__record_literal_no_const, 5, 0, 0), + [2944] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__record_literal_no_const, 5, 0, 0), + [2946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_cast, 2, 0, 0), + [2948] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_cast, 2, 0, 0), + [2950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 5, 0, 70), + [2952] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 5, 0, 70), + [2954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__cascade_assignment_section, 2, 0, 0), + [2956] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__cascade_assignment_section, 2, 0, 0), + [2958] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(264), + [2961] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3214), + [2964] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3403), + [2967] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_cascade_section_repeat2, 2, 0, 0), SHIFT_REPEAT(3404), + [2970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_invocation, 5, 0, 0), + [2972] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constructor_invocation, 5, 0, 0), + [2974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression_body, 2, 0, 0), + [2976] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression_body, 2, 0, 0), + [2978] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(1067), + [2981] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(2058), + [2984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 3, 0, 0), + [2986] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 3, 0, 0), + [2988] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 2, 0, 0), + [2990] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 2, 0, 0), + [2992] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1716), + [2995] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1067), + [2998] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1716), + [3002] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1067), + [3006] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1716), + [3009] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1067), + [3012] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__assignable_selector_part, 1, 0, 0), REDUCE(sym_selector, 1, 0, 0), + [3015] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__assignable_selector_part, 1, 0, 0), REDUCE(sym_selector, 1, 0, 0), + [3018] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_assignable_expression, 2, 0, 0), REDUCE(sym__primary, 2, 0, 0), + [3021] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_assignable_expression, 2, 0, 0), REDUCE(sym__primary, 2, 0, 0), + [3024] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_selector, 1, 0, 0), REDUCE(sym__assignable_selector_part, 2, 0, 0), + [3027] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_selector, 1, 0, 0), REDUCE(sym__assignable_selector_part, 2, 0, 0), + [3030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 6, 0, 87), + [3032] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 6, 0, 87), + [3034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 6, 0, 0), + [3036] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 6, 0, 0), + [3038] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 6, 0, 0), + [3040] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 6, 0, 0), + [3042] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cascade_section, 5, 0, 0), + [3044] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cascade_section, 5, 0, 0), + [3046] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 7, 0, 100), + [3048] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 7, 0, 100), + [3050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_super, 1, 0, 0), + [3052] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_super, 1, 0, 0), + [3054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_this, 1, 0, 0), + [3056] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_this, 1, 0, 0), + [3058] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_set_or_map_literal, 7, 0, 0), + [3060] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_set_or_map_literal, 7, 0, 0), + [3062] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 7, 0, 0), + [3064] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 7, 0, 0), + [3066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__get, 1, 0, 0), + [3068] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__get, 1, 0, 0), + [3070] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__set, 1, 0, 0), + [3072] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__set, 1, 0, 0), + [3074] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__exclamation_operator, 1, 0, 0), + [3076] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__exclamation_operator, 1, 0, 0), + [3078] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__new_builtin, 1, 0, 0), + [3080] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__new_builtin, 1, 0, 0), + [3082] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_literal, 2, 0, 0), + [3084] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_literal, 2, 0, 0), + [3086] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__numeric_literal, 1, 0, 0), + [3088] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__numeric_literal, 1, 0, 0), + [3090] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_true, 1, 0, 0), + [3092] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_true, 1, 0, 0), + [3094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_false, 1, 0, 0), + [3096] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_false, 1, 0, 0), + [3098] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_const_object_expression, 3, 0, 0), + [3100] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_const_object_expression, 3, 0, 0), + [3102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_null_literal, 1, 0, 0), + [3104] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_null_literal, 1, 0, 0), + [3106] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_throw_expression, 2, 0, 0), + [3108] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_throw_expression, 2, 0, 0), + [3110] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_throw_expression_without_cascade, 2, 0, 0), + [3112] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_throw_expression_without_cascade, 2, 0, 0), + [3114] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_expression, 3, 0, 40), + [3116] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_expression, 3, 0, 40), + [3118] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 1, 0, 0), + [3120] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 1, 0, 0), + [3122] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), SHIFT(1067), + [3125] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(1067), + [3128] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_name, 1, 0, 1), SHIFT(3387), + [3131] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__primary, 1, 0, 9), SHIFT(706), + [3134] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__primary, 1, 0, 9), SHIFT(2337), + [3137] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), SHIFT_REPEAT(2496), + [3140] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 2, 0, 0), SHIFT(2496), + [3143] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), SHIFT(1067), + [3146] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(363), + [3149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat1, 2, 0, 0), + [3151] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat1, 2, 0, 0), + [3153] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat1, 2, 0, 0), SHIFT_REPEAT(3262), + [3156] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat1, 2, 0, 0), SHIFT_REPEAT(2355), + [3159] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat1, 2, 0, 0), SHIFT_REPEAT(2344), + [3162] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(361), + [3165] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(364), + [3168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2016), + [3170] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(365), + [3173] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), REDUCE(sym_list_pattern, 2, 0, 0), + [3176] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), REDUCE(sym_list_pattern, 2, 0, 0), + [3179] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 3, 0, 0), REDUCE(sym_map_pattern, 3, 0, 0), + [3182] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 3, 0, 0), REDUCE(sym_map_pattern, 3, 0, 0), + [3185] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), REDUCE(sym_map_pattern, 2, 0, 0), + [3188] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 2, 0, 0), REDUCE(sym_map_pattern, 2, 0, 0), + [3191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_annotation, 2, 0, 2), + [3193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [3195] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_annotation, 2, 0, 2), + [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2028), + [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3585), + [3201] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), REDUCE(sym_list_pattern, 3, 0, 0), + [3204] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), REDUCE(sym_list_pattern, 3, 0, 0), + [3207] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__identifier_or_new, 1, 0, 0), REDUCE(sym_constructor_tearoff, 3, 0, 0), + [3210] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__identifier_or_new, 1, 0, 0), REDUCE(sym_constructor_tearoff, 3, 0, 0), + [3213] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__primary, 1, 0, 0), SHIFT(3495), + [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1704), + [3218] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1386), + [3222] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2345), + [3226] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 6, 0, 0), REDUCE(sym_constant_pattern, 6, 0, 0), + [3229] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 6, 0, 0), REDUCE(sym_constant_pattern, 6, 0, 0), + [3232] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 6, 0, 0), REDUCE(sym_constant_pattern, 6, 0, 0), + [3235] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 6, 0, 0), REDUCE(sym_constant_pattern, 6, 0, 0), + [3238] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 7, 0, 0), REDUCE(sym_constant_pattern, 7, 0, 0), + [3241] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 7, 0, 0), REDUCE(sym_constant_pattern, 7, 0, 0), + [3244] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 7, 0, 0), REDUCE(sym_constant_pattern, 7, 0, 0), + [3247] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 7, 0, 0), REDUCE(sym_constant_pattern, 7, 0, 0), + [3250] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1386), + [3253] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2345), + [3256] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 5, 0, 0), REDUCE(sym_constant_pattern, 5, 0, 0), + [3259] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 5, 0, 0), REDUCE(sym_constant_pattern, 5, 0, 0), + [3262] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_set_or_map_literal, 4, 0, 0), REDUCE(sym_constant_pattern, 4, 0, 0), + [3265] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_set_or_map_literal, 4, 0, 0), REDUCE(sym_constant_pattern, 4, 0, 0), + [3268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__assignment_operator, 1, 0, 0), + [3270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__assignment_operator, 1, 0, 0), + [3272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prefix_operator, 1, 0, 0), + [3274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prefix_operator, 1, 0, 0), + [3276] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_prefix_operator, 1, 0, 0), SHIFT(2133), + [3279] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_prefix_operator, 1, 0, 0), SHIFT(2133), + [3282] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__literal, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), + [3285] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__literal, 1, 0, 0), REDUCE(sym_constant_pattern, 1, 0, 0), + [3288] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), REDUCE(sym_constant_pattern, 4, 0, 0), + [3291] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), REDUCE(sym_constant_pattern, 4, 0, 0), + [3294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_list_literal, 5, 0, 0), REDUCE(sym_constant_pattern, 5, 0, 0), + [3297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_list_literal, 5, 0, 0), REDUCE(sym_constant_pattern, 5, 0, 0), + [3300] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scoped_identifier, 3, 0, 12), + [3302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scoped_identifier, 3, 0, 12), + [3304] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1386), + [3307] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1386), + [3311] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1387), + [3313] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1386), + [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), + [3318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__metadata, 1, 0, 0), + [3320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__metadata, 1, 0, 0), + [3322] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(1390), + [3325] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__metadata_repeat1, 2, 0, 0), + [3327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__metadata_repeat1, 2, 0, 0), + [3329] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__metadata_repeat1, 2, 0, 0), SHIFT_REPEAT(3082), + [3332] = {.entry = {.count = 1, .reusable = false}}, SHIFT(978), + [3334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1505), + [3336] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1092), + [3338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344), + [3340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [3342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3450), + [3344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [3346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [3348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [3350] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1499), + [3354] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2356), + [3358] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1499), + [3361] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2356), + [3364] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_operator, 1, 0, 0), + [3366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_operator, 1, 0, 0), + [3368] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(1386), + [3371] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(2050), + [3374] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shift_operator, 1, 0, 0), + [3376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shift_operator, 1, 0, 0), + [3378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_negation_operator, 1, 0, 0), + [3380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_negation_operator, 1, 0, 0), + [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), + [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3522), + [3388] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__multiplicative_operator, 1, 0, 0), + [3390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__multiplicative_operator, 1, 0, 0), + [3392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3507), + [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3470), + [3396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__shift_operator, 1, 0, 0), + [3398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__shift_operator, 1, 0, 0), + [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3605), + [3402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_operator, 1, 0, 0), + [3404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_operator, 1, 0, 0), + [3406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), + [3408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), + [3410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_operator, 1, 0, 0), + [3412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_operator, 1, 0, 0), + [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [3416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [3418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [3420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [3422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3460), + [3424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3390), + [3426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3535), + [3428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tilde_operator, 1, 0, 0), + [3430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tilde_operator, 1, 0, 0), + [3432] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_operator, 1, 0, 0), + [3434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_operator, 1, 0, 0), + [3436] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1499), + [3439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1662), + [3441] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), SHIFT(1386), + [3444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), + [3446] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1499), + [3450] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(1467), + [3453] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), SHIFT(1386), + [3456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_annotation, 3, 0, 2), + [3458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_annotation, 3, 0, 2), + [3460] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(1386), + [3463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [3465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3350), + [3467] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1499), + [3470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_annotation, 4, 0, 2), + [3472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_annotation, 4, 0, 2), + [3474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__metadata_repeat1, 1, 0, 0), + [3476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__metadata_repeat1, 1, 0, 0), + [3478] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(353), + [3481] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat2, 2, 0, 0), + [3483] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat2, 2, 0, 0), + [3485] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat2, 2, 0, 0), SHIFT_REPEAT(3082), + [3488] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_program_repeat2, 2, 0, 0), SHIFT_REPEAT(1912), + [3491] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3330), + [3493] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(1499), + [3496] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(2060), + [3499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1681), + [3501] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1598), + [3505] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2349), + [3509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_builtin, 1, 0, 0), + [3511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_builtin, 1, 0, 0), + [3513] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(309), + [3516] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1598), + [3519] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(2349), + [3522] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(350), + [3525] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(347), + [3528] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(1499), + [3531] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1598), + [3535] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__metadata_repeat1, 2, 0, 0), SHIFT_REPEAT(3262), + [3538] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2272), + [3541] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2273), + [3544] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2209), + [3547] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2198), + [3550] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2331), + [3553] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2332), + [3556] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2275), + [3559] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2276), + [3562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1690), + [3564] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1566), + [3567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2337), + [3569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1613), + [3571] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1598), + [3574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat3, 2, 0, 0), + [3576] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat3, 2, 0, 0), + [3578] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat3, 2, 0, 0), SHIFT_REPEAT(3262), + [3581] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_program_repeat3, 2, 0, 0), SHIFT_REPEAT(1829), + [3584] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1598), + [3587] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), SHIFT(1499), + [3590] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), SHIFT(1499), + [3593] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(1613), + [3596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3593), + [3598] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2835), + [3600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3597), + [3602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2835), + [3604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3362), + [3606] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(341), + [3609] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(344), + [3612] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(345), + [3615] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(346), + [3618] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3037), + [3620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3037), + [3622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_script_tag, 3, 0, 0), + [3624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_script_tag, 3, 0, 0), + [3626] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(1598), + [3629] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), SHIFT(2054), + [3632] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2987), + [3634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2987), + [3636] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2991), + [3638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2991), + [3640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2693), + [3642] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1566), + [3645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat1, 1, 0, 0), + [3647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat1, 1, 0, 0), + [3649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_name, 4, 0, 0), + [3651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_name, 4, 0, 0), + [3653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_export, 4, 0, 0), + [3655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_export, 4, 0, 0), + [3657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_export, 5, 0, 0), + [3659] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_export, 5, 0, 0), + [3661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_or_export, 1, 0, 0), + [3663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_or_export, 1, 0, 0), + [3665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_specification, 5, 0, 0), + [3667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_specification, 5, 0, 0), + [3669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_name, 3, 0, 0), + [3671] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_name, 3, 0, 0), + [3673] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), SHIFT(1598), + [3676] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__function_type_tails, 2, 0, 0), SHIFT_REPEAT(1661), + [3679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_export, 3, 0, 0), + [3681] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_export, 3, 0, 0), + [3683] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(1598), + [3686] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 1, 0, 0), SHIFT(165), + [3689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_import, 1, 0, 0), + [3691] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_import, 1, 0, 0), + [3693] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__type_not_void, 1, 0, 0), SHIFT(1598), + [3696] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__cascade_subsection, 2, 0, 0), SHIFT(165), + [3699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_specification, 6, 0, 0), + [3701] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_specification, 6, 0, 0), + [3703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_specification, 4, 0, 0), + [3705] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_specification, 4, 0, 0), + [3707] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1566), + [3710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_specification, 3, 0, 0), + [3712] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_specification, 3, 0, 0), + [3714] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_library_import, 2, 0, 0), + [3716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_library_import, 2, 0, 0), + [3718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_specification, 7, 0, 0), + [3720] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_specification, 7, 0, 0), + [3722] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(319), + [3725] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(320), + [3728] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external_and_static, 1, 0, 0), SHIFT(2252), + [3731] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__external_and_static, 1, 0, 0), SHIFT(1838), + [3734] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external_and_static, 1, 0, 0), SHIFT(1920), + [3737] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external_and_static, 1, 0, 0), SHIFT(1661), + [3740] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__external_and_static, 1, 0, 0), + [3742] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2687), + [3744] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 4, 0, 0), SHIFT(1566), + [3747] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(316), + [3750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3393), + [3752] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__if_null_expression, 2, 0, 39), SHIFT_REPEAT(356), + [3755] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(318), + [3758] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_or_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(358), + [3761] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bitwise_xor_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(359), + [3764] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_bitwise_and_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(360), + [3767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1828), + [3769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1910), + [3771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1627), + [3773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1639), + [3775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [3777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1631), + [3779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_part_directive, 3, 0, 0), + [3781] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_part_directive, 3, 0, 0), + [3783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), + [3785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1701), + [3787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [3789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), + [3791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [3793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), + [3795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat2, 1, 0, 0), + [3797] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat2, 1, 0, 0), + [3799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [3801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1717), + [3803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1515), + [3805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), + [3807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1513), + [3809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), + [3811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [3813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [3815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_part_directive, 4, 0, 0), + [3817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_part_directive, 4, 0, 0), + [3819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_part_of_directive, 3, 0, 0), + [3821] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_part_of_directive, 3, 0, 0), + [3823] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2251), + [3826] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2288), + [3829] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2205), + [3832] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2199), + [3835] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2297), + [3838] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2298), + [3841] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2253), + [3844] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(2254), + [3847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat3, 1, 0, 0), + [3849] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat3, 1, 0, 0), + [3851] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__native, 1, 0, 0), + [3853] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__native, 1, 0, 0), + [3855] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_part_of_directive, 4, 0, 0), + [3857] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_part_of_directive, 4, 0, 0), + [3859] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 7, 0, 64), + [3861] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 7, 0, 64), + [3863] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 6, 0, 54), + [3865] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 6, 0, 54), + [3867] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_body, 3, 0, 0), + [3869] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_body, 3, 0, 0), + [3871] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 6, 0, 0), + [3873] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 6, 0, 0), + [3875] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 8, 0, 0), + [3877] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 8, 0, 0), + [3879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_body, 4, 0, 0), + [3881] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_body, 4, 0, 0), + [3883] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 3, 0, 0), + [3885] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 3, 0, 0), + [3887] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 2, 0, 0), + [3889] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 2, 0, 0), + [3891] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 6, 0, 42), + [3893] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 6, 0, 42), + [3895] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(1662), + [3898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_body, 6, 0, 0), + [3900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_body, 6, 0, 0), + [3902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 7, 0, 61), + [3904] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 7, 0, 61), + [3906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 7, 0, 0), + [3908] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 7, 0, 0), + [3910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 7, 0, 0), + [3912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 7, 0, 0), + [3914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_body, 3, 0, 0), + [3916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_body, 3, 0, 0), + [3918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_application_class, 5, 0, 0), + [3920] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_application_class, 5, 0, 0), + [3922] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 4, 0, 0), + [3924] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 4, 0, 0), + [3926] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 6, 0, 0), + [3928] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 6, 0, 0), + [3930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 4, 0, 14), + [3932] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 4, 0, 14), + [3934] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_application_class, 4, 0, 0), + [3936] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_application_class, 4, 0, 0), + [3938] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 7, 0, 66), + [3940] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 7, 0, 66), + [3942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 28), + [3944] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 28), + [3946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 6, 0, 46), + [3948] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 6, 0, 46), + [3950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 4, 0, 0), + [3952] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 4, 0, 0), + [3954] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 1, 0, 0), SHIFT(1662), + [3957] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 3, 0, 0), + [3959] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 3, 0, 0), + [3961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 4, 0, 16), + [3963] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 4, 0, 16), + [3965] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 4, 0, 17), + [3967] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 4, 0, 17), + [3969] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 7, 0, 62), + [3971] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 7, 0, 62), + [3973] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 4, 0, 18), + [3975] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 4, 0, 18), + [3977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 29), + [3979] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 29), + [3981] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 5, 0, 25), + [3983] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 5, 0, 25), + [3985] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 7, 0, 67), + [3987] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 7, 0, 67), + [3989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 3, 0, 5), + [3991] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 3, 0, 5), + [3993] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_program_repeat4, 1, 0, 0), + [3995] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_program_repeat4, 1, 0, 0), + [3997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 4, 0, 19), + [3999] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 4, 0, 19), + [4001] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_body, 5, 0, 0), + [4003] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_body, 5, 0, 0), + [4005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 6, 0, 48), + [4007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 6, 0, 48), + [4009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 6, 0, 49), + [4011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 6, 0, 49), + [4013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 5, 0, 0), + [4015] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 5, 0, 0), + [4017] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 30), + [4019] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 30), + [4021] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 9, 0, 99), + [4023] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 9, 0, 99), + [4025] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 6, 0, 50), + [4027] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 6, 0, 50), + [4029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 9, 0, 0), + [4031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 9, 0, 0), + [4033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 5, 0, 31), + [4035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 5, 0, 31), + [4037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 7, 0, 68), + [4039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 7, 0, 68), + [4041] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 6, 0, 43), + [4043] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 6, 0, 43), + [4045] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 5, 0, 32), + [4047] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 5, 0, 32), + [4049] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_body, 2, 0, 0), + [4051] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_body, 2, 0, 0), + [4053] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 3, 0, 5), + [4055] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 3, 0, 5), + [4057] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 6, 0, 44), + [4059] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 6, 0, 44), + [4061] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_body, 3, 0, 0), + [4063] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_body, 3, 0, 0), + [4065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 8, 0, 83), + [4067] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 8, 0, 83), + [4069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_body, 2, 0, 0), + [4071] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_body, 2, 0, 0), + [4073] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 5, 0, 26), + [4075] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 5, 0, 26), + [4077] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 4, 0, 0), + [4079] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 4, 0, 0), + [4081] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 8, 0, 85), + [4083] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 8, 0, 85), + [4085] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 5, 0, 0), + [4087] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 5, 0, 0), + [4089] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 5, 0, 23), + [4091] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 5, 0, 23), + [4093] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 2, 0, 0), + [4095] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 2, 0, 0), + [4097] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_declaration, 6, 0, 51), + [4099] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_declaration, 6, 0, 51), + [4101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 3, 0, 0), + [4103] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 3, 0, 0), + [4105] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 4, 0, 13), + [4107] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 4, 0, 13), + [4109] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 4, 0, 19), + [4111] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 4, 0, 19), + [4113] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 6, 0, 52), + [4115] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 6, 0, 52), + [4117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__top_level_definition, 1, 0, 0), + [4119] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__top_level_definition, 1, 0, 0), + [4121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 8, 0, 86), + [4123] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 8, 0, 86), + [4125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 6, 0, 45), + [4127] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 6, 0, 45), + [4129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 7, 0, 69), + [4131] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 7, 0, 69), + [4133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 6, 0, 0), + [4135] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 6, 0, 0), + [4137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 33), + [4139] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 33), + [4141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 34), + [4143] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 34), + [4145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 6, 0, 53), + [4147] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 6, 0, 53), + [4149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_definition, 5, 0, 35), + [4151] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_definition, 5, 0, 35), + [4153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extension_type_declaration, 5, 0, 24), + [4155] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extension_type_declaration, 5, 0, 24), + [4157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_declaration, 5, 0, 0), + [4159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin_declaration, 5, 0, 0), + [4161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_body, 7, 0, 0), + [4163] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_body, 7, 0, 0), + [4165] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type, 1, 0, 0), + [4167] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type, 1, 0, 0), + [4169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3580), + [4171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3474), + [4173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1981), + [4175] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), SHIFT(1662), + [4178] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__external, 1, 0, 0), SHIFT(1838), + [4181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), SHIFT(1920), + [4184] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), + [4186] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), SHIFT(1661), + [4189] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), SHIFT(2307), + [4192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__external, 1, 0, 0), SHIFT(2180), + [4195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2204), + [4197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2558), + [4199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 1, 0, 0), SHIFT(2196), + [4202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [4204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [4206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [4208] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 1, 0, 0), + [4210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_function, 1, 0, 0), + [4212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [4214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [4216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [4218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3382), + [4220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1908), + [4222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3583), + [4224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3542), + [4226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3554), + [4228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3591), + [4230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1921), + [4232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), + [4234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2119), + [4236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3586), + [4238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3590), + [4240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1924), + [4242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), + [4244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1925), + [4246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [4248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1926), + [4250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), + [4252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3513), + [4254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1927), + [4256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [4258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1928), + [4260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [4262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1929), + [4264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1624), + [4266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1930), + [4268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), + [4270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1931), + [4272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), + [4274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1932), + [4276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), + [4278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1933), + [4280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [4282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1934), + [4284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), + [4286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1907), + [4288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [4290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1935), + [4292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), + [4294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1922), + [4296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), + [4298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1906), + [4300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), + [4302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3363), + [4304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3471), + [4306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3527), + [4308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3546), + [4310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3569), + [4312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3512), + [4314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3623), + [4316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3340), + [4318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3358), + [4320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3364), + [4322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3536), + [4324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3582), + [4326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3610), + [4328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3624), + [4330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3628), + [4332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3370), + [4334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3379), + [4336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3383), + [4338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3384), + [4340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3408), + [4342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3414), + [4344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3416), + [4346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3417), + [4348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3418), + [4350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1914), + [4352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1686), + [4354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [4356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(706), + [4358] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_name, 1, 0, 1), SHIFT(2337), + [4361] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type_not_function, 2, 0, 0), + [4363] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__operator, 1, 0, 0), + [4365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__operator, 1, 0, 0), + [4367] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 1, 0, 0), + [4369] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_constant_pattern, 1, 0, 0), REDUCE(sym__type_name, 1, 0, 1), + [4372] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant_pattern, 1, 0, 0), + [4374] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_name, 1, 0, 1), SHIFT(3393), + [4377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2196), + [4379] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__type, 2, 0, 0), + [4381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type, 2, 0, 0), + [4383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [4385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [4387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [4389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [4391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3219), + [4393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2033), + [4395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3426), + [4397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3427), + [4399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [4401] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3183), + [4403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3326), + [4405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3327), + [4407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [4409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [4411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [4413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [4415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [4417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [4419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [4421] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3228), + [4423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3455), + [4425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3456), + [4427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [4429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [4431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [4433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1506), + [4435] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 2, 0, 0), + [4437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [4439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [4441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1391), + [4443] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 2, 0, 0), + [4445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1317), + [4447] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_enum_body_repeat2, 3, 0, 0), + [4449] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat2, 3, 0, 0), + [4451] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(268), + [4454] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(164), + [4457] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3224), + [4460] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(2033), + [4463] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(1085), + [4466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3437), + [4469] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__assignable_selector_part_repeat1, 2, 0, 0), SHIFT_REPEAT(3438), + [4472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_extension_body_repeat1, 3, 0, 0), + [4474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extension_body_repeat1, 3, 0, 0), + [4476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__simple_formal_parameter, 2, 0, 0), + [4478] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 2, 0, 0), SHIFT(1662), + [4481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 2, 0, 0), + [4483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2221), + [4485] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(1662), + [4489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), + [4491] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_name, 1, 0, 1), REDUCE(sym__simple_formal_parameter, 1, 0, 0), + [4494] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2392), + [4496] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 1, 0, 0), REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(1662), + [4500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_pattern, 5, 0, 0), + [4502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_pattern, 5, 0, 0), + [4504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__strict_formal_parameter_list, 3, 0, 0), + [4506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__strict_formal_parameter_list, 3, 0, 0), + [4508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_pattern, 5, 0, 0), + [4510] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_pattern, 5, 0, 0), + [4512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2447), + [4514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__strict_formal_parameter_list, 2, 0, 0), + [4516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__strict_formal_parameter_list, 2, 0, 0), + [4518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__identifier_or_new, 1, 0, 0), + [4520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), + [4522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3247), + [4524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 5, 0, 0), + [4526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_pattern, 5, 0, 0), + [4528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__formal_parameter_part, 2, 0, 0), + [4530] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__formal_parameter_part, 2, 0, 0), + [4532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1243), + [4534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_pattern, 6, 0, 0), + [4536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_pattern, 6, 0, 0), + [4538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 0), + [4540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_pattern, 6, 0, 0), + [4542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_pattern, 6, 0, 0), + [4544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_pattern, 6, 0, 0), + [4546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parenthesized_pattern, 3, 0, 0), + [4548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__parenthesized_pattern, 3, 0, 0), + [4550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 0), + [4552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [4554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 0), + [4556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_pattern, 4, 0, 0), + [4558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_pattern, 2, 0, 0), + [4560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1629), + [4562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__strict_formal_parameter_list, 4, 0, 0), + [4564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__strict_formal_parameter_list, 4, 0, 0), + [4566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [4568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [4570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), + [4572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_pattern, 7, 0, 0), + [4574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_pattern, 7, 0, 0), + [4576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_pattern, 5, 0, 0), + [4578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_pattern, 5, 0, 0), + [4580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_pattern, 4, 0, 0), + [4582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_pattern, 4, 0, 0), + [4584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2678), + [4586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), + [4588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_pattern, 3, 0, 0), + [4590] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_pattern, 3, 0, 0), + [4592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_pattern, 3, 0, 0), + [4594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__formal_parameter_part, 1, 0, 0), + [4596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__formal_parameter_part, 1, 0, 0), + [4598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_formal_parameter_list, 1, 0, 0), + [4600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_formal_parameter_list, 1, 0, 0), + [4602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_pattern, 4, 0, 0), + [4604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_pattern, 4, 0, 0), + [4606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_pattern, 4, 0, 0), + [4608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_pattern, 4, 0, 0), + [4610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__strict_formal_parameter_list, 5, 0, 0), + [4612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__strict_formal_parameter_list, 5, 0, 0), + [4614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [4616] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2234), + [4618] = {.entry = {.count = 1, .reusable = false}}, SHIFT(823), + [4620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1870), + [4622] = {.entry = {.count = 1, .reusable = false}}, SHIFT(856), + [4624] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1429), + [4626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1874), + [4628] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1467), + [4630] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1009), + [4632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1877), + [4634] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1060), + [4636] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1351), + [4638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1859), + [4640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1390), + [4642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1524), + [4644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1867), + [4646] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1613), + [4648] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), SHIFT_REPEAT(2470), + [4651] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(1662), + [4654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [4656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2717), + [4658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified, 3, 0, 0), + [4660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 5, 0, 0), + [4662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(589), + [4664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2075), + [4666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2103), + [4668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2041), + [4670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2702), + [4672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 4, 0, 0), + [4674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_param, 3, 0, 0), + [4676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_super_formal_parameter, 3, 0, 0), + [4678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2113), + [4680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2089), + [4682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 6, 0, 0), + [4684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__unary_pattern, 1, 0, 0), + [4686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2213), + [4688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2214), + [4690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2117), + [4692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified, 5, 0, 0), + [4694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__primary_pattern, 1, 0, 0), + [4696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 7, 0, 0), + [4698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_pattern, 2, 0, 0), + [4700] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_pattern, 2, 0, 0), + [4702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2557), + [4704] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__required, 1, 0, 0), + [4706] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__required, 1, 0, 0), + [4708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_param, 4, 0, 0), + [4710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_super_formal_parameter, 4, 0, 0), + [4712] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1690), + [4715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__logical_and_pattern, 1, 0, 0), + [4717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), + [4719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 6, 0, 0), + [4721] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_initializer, 6, 0, 0), + [4723] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__logical_and_pattern_repeat1, 2, 0, 0), + [4725] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__logical_and_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1433), + [4728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__logical_and_pattern, 2, 0, 0), + [4730] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 1, 0, 0), REDUCE(sym__function_type_tail, 1, 0, 0), SHIFT(1690), + [4734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 4, 0, 0), + [4736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_initializer, 4, 0, 0), + [4738] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), SHIFT_REPEAT(2529), + [4741] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_repeat1, 2, 0, 0), SHIFT_REPEAT(2471), + [4744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__logical_or_pattern, 2, 0, 0), + [4746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), + [4748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3429), + [4750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(550), + [4752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2571), + [4754] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2554), + [4756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2554), + [4758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(812), + [4760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2843), + [4762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2553), + [4764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__logical_or_pattern_repeat1, 2, 0, 0), + [4766] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__logical_or_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1434), + [4769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2514), + [4771] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2514), + [4773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), + [4775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2893), + [4777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2473), + [4779] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__static, 1, 0, 0), + [4781] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__static, 1, 0, 0), + [4783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(626), + [4785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), + [4787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(792), + [4789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(793), + [4791] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2554), + [4794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2554), + [4797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 2, 0, 0), + [4799] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2843), + [4802] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2553), + [4805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [4807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__outer_pattern, 1, 0, 0), + [4809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1998), + [4811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), + [4813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__external_builtin, 1, 0, 0), + [4815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__external_builtin, 1, 0, 0), + [4817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(738), + [4819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1842), + [4821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1897), + [4823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2006), + [4825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(730), + [4827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2052), + [4829] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2514), + [4832] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2514), + [4835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 2, 0, 0), + [4837] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2893), + [4840] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2473), + [4843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__logical_or_pattern, 1, 0, 0), + [4845] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 1), REDUCE(sym__type_name, 1, 0, 1), + [4848] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__type_name, 1, 0, 1), SHIFT(1566), + [4851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2096), + [4853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2004), + [4855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1841), + [4857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(739), + [4859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1863), + [4861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [4863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1997), + [4865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(749), + [4867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2596), + [4869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2970), + [4871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2603), + [4873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_null_check_pattern, 2, 0, 0), + [4875] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_null_assert_pattern, 2, 0, 0), + [4877] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1690), + [4880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [4882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [4884] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2889), + [4886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3132), + [4888] = {.entry = {.count = 3, .reusable = true}}, REDUCE(sym__type_not_void_not_function, 2, 0, 0), REDUCE(sym__function_type_tail, 2, 0, 0), SHIFT(1690), + [4892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), + [4894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2626), + [4896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), + [4898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2767), + [4900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2612), + [4902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_identifier, 1, 0, 0), + [4904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [4906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2533), + [4908] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_repeat1, 2, 0, 0), + [4910] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2596), + [4913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2970), + [4916] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2603), + [4919] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2626), + [4922] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_repeat1, 2, 0, 0), + [4924] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2767), + [4927] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2612), + [4930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_pattern, 3, 0, 0), + [4932] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2389), + [4935] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2389), + [4938] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 2, 0, 0), + [4940] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2352), + [4943] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_configurable_uri, 1, 0, 0), + [4945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3191), + [4947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3533), + [4949] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2411), + [4952] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2411), + [4955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 2, 0, 0), + [4957] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 2, 0, 0), SHIFT_REPEAT(2313), + [4960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 1, 0, 3), + [4962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2845), + [4964] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3550), + [4966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3349), + [4968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 1, 0, 0), + [4970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [4972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), + [4974] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2389), + [4976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2389), + [4978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [4980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2352), + [4982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2411), + [4984] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2411), + [4986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [4988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2313), + [4990] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_final_builtin, 1, 0, 0), + [4992] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_final_builtin, 1, 0, 0), + [4994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(729), + [4996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(737), + [4998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(742), + [5000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), + [5002] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_switch_block_repeat1, 2, 0, 0), SHIFT_REPEAT(3429), + [5005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_switch_block_repeat1, 2, 0, 0), + [5007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_switch_block_repeat1, 2, 0, 0), + [5009] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_switch_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1436), + [5012] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_signature, 1, 0, 0), + [5014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2287), + [5016] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 0), + [5018] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_signature, 1, 0, 0), + [5020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), + [5022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), + [5024] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3472), + [5026] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_inferred_type, 1, 0, 0), + [5028] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inferred_type, 1, 0, 0), + [5030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2007), + [5032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2013), + [5034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2020), + [5036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2025), + [5038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1996), + [5040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2001), + [5042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2002), + [5044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 2, 0, 2), + [5046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2758), + [5048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), + [5050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), + [5052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), + [5054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(799), + [5056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), + [5058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), + [5060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), + [5062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(796), + [5064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(797), + [5066] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__function_type_tail, 3, 0, 0), SHIFT(1690), + [5069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1858), + [5071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1862), + [5073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1836), + [5075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1837), + [5077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1839), + [5079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1840), + [5081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1845), + [5083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1846), + [5085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3619), + [5087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3334), + [5089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3625), + [5091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3086), + [5093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3163), + [5095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(608), + [5097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [5099] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__relational_pattern, 1, 0, 0), + [5101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1999), + [5103] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__declared_identifier, 2, 0, 2), REDUCE(sym__declared_identifier, 3, 0, 10), + [5106] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__declared_identifier, 3, 0, 10), + [5108] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_typed_identifier, 2, 0, 0), + [5110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2039), + [5112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_initializers_repeat1, 2, 0, 0), + [5114] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_initializers_repeat1, 2, 0, 0), SHIFT_REPEAT(2233), + [5117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_initializers_repeat1, 2, 0, 0), + [5119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_repeat1, 2, 0, 0), + [5121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2531), + [5124] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2423), + [5127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter_signature, 2, 0, 2), + [5129] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter_signature, 2, 0, 2), + [5131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1733), + [5133] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2500), + [5136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_repeat1, 2, 0, 0), + [5138] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_repeat1, 2, 0, 0), SHIFT_REPEAT(2374), + [5141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1995), + [5143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2531), + [5145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2423), + [5147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2500), + [5149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2012), + [5151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2374), + [5153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 2, 0, 4), + [5155] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 2, 0, 4), + [5157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 2, 0, 3), + [5159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 2, 0, 3), + [5161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2232), + [5163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(577), + [5165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type_field, 3, 0, 0), + [5167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2027), + [5169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2000), + [5171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), + [5173] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__declared_identifier, 3, 0, 10), REDUCE(sym__declared_identifier, 4, 0, 47), + [5176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__declared_identifier, 4, 0, 47), + [5178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(580), + [5180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3394), + [5182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1617), + [5184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3232), + [5186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2067), + [5188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2505), + [5190] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_configuration_uri_condition, 3, 0, 0), + [5192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_configuration_uri_condition, 3, 0, 0), + [5194] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 1, 0, 0), + [5196] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2367), + [5198] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_multiple_repeat1, 1, 0, 0), + [5200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3633), + [5202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3332), + [5204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter_signature, 4, 0, 10), + [5206] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter_signature, 4, 0, 10), + [5208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2057), + [5210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_formal_parameter, 2, 0, 0), + [5212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [5214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(784), + [5216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_formal_parameter, 4, 0, 0), + [5218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initializers, 3, 0, 0), + [5220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2233), + [5222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_initializers, 3, 0, 0), + [5224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operator_signature, 4, 0, 0), + [5226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operator_signature, 4, 0, 0), + [5228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(794), + [5230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), + [5232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), + [5234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initializers, 2, 0, 0), + [5236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_initializers, 2, 0, 0), + [5238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), + [5240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), + [5242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), + [5244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1834), + [5246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1835), + [5248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operator_signature, 3, 0, 0), + [5250] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operator_signature, 3, 0, 0), + [5252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [5254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type_field, 2, 0, 0), + [5256] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 3, 0, 2), + [5258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 3, 0, 2), + [5260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1843), + [5262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1844), + [5264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter_signature, 3, 0, 10), + [5266] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter_signature, 3, 0, 10), + [5268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), + [5270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(741), + [5272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 3, 0, 11), + [5274] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 3, 0, 11), + [5276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__import, 1, 0, 0), + [5278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__import, 1, 0, 0), + [5280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__covariant, 1, 0, 0), + [5282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__covariant, 1, 0, 0), + [5284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_formal_parameter, 3, 0, 0), + [5286] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 1, 0, 0), + [5288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2362), + [5290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_multiple_repeat1, 1, 0, 0), + [5292] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__formal_parameter_part, 1, 0, 0), REDUCE(sym_constructor_signature, 2, 0, 27), + [5295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_signature, 2, 0, 27), + [5297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__formal_parameter_part, 1, 0, 0), REDUCE(sym_constructor_signature, 2, 0, 27), + [5300] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__export, 1, 0, 0), + [5302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__export, 1, 0, 0), + [5304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter_signature, 3, 0, 2), + [5306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter_signature, 3, 0, 2), + [5308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__declared_identifier, 2, 0, 2), + [5310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__sub_string_test, 2, 0, 0), + [5312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__sub_string_test, 2, 0, 0), + [5314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_signature, 4, 0, 65), + [5316] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constructor_signature, 4, 0, 65), + [5318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initializer_list_entry, 2, 0, 0), + [5320] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_initializer_list_entry, 2, 0, 0), + [5322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_factory_constructor_signature, 4, 0, 0), + [5324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2120), + [5326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_factory_constructor_signature, 4, 0, 0), + [5328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_single_quotes_repeat1, 1, 0, 0), + [5330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2544), + [5332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_single_quotes_repeat1, 1, 0, 0), + [5334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_configurable_uri_repeat1, 2, 0, 0), + [5336] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_configurable_uri_repeat1, 2, 0, 0), SHIFT_REPEAT(3191), + [5339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [5341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [5343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2788), + [5345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3195), + [5347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1918), + [5349] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(2469), + [5352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_arguments, 4, 0, 0), + [5354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_arguments, 4, 0, 0), + [5356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2295), + [5358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2220), + [5360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [5362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [5364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2844), + [5366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3073), + [5368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [5370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [5372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2863), + [5374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3099), + [5376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_factory_constructor_signature, 3, 0, 0), + [5378] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2084), + [5380] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_factory_constructor_signature, 3, 0, 0), + [5382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__raw_string_literal_double_quotes_repeat1, 1, 0, 0), + [5384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2475), + [5386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__raw_string_literal_double_quotes_repeat1, 1, 0, 0), + [5388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_arguments, 5, 0, 0), + [5390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_arguments, 5, 0, 0), + [5392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion, 2, 0, 0), + [5394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion, 2, 0, 0), + [5396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [5398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [5400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2912), + [5402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3156), + [5404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initializer_list_entry, 4, 0, 0), + [5406] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_initializer_list_entry, 4, 0, 0), + [5408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2340), + [5410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2507), + [5412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_configurable_uri, 2, 0, 0), + [5414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2484), + [5416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_arguments, 6, 0, 0), + [5418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_arguments, 6, 0, 0), + [5420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2774), + [5422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2528), + [5424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_arguments, 3, 0, 0), + [5426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_arguments, 3, 0, 0), + [5428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pattern, 1, 0, 0), + [5430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2979), + [5432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2526), + [5434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initializer_list_entry, 1, 0, 0), + [5436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_initializer_list_entry, 1, 0, 0), + [5438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__external_and_static, 2, 0, 0), + [5440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__external_and_static, 2, 0, 0), + [5442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1196), + [5444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3424), + [5446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 1, 0, 0), + [5448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 1, 0, 0), + [5450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 2, 0, 0), + [5452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 0), + [5454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 1, 0, 6), + [5456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abstract, 1, 0, 0), + [5458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(584), + [5460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [5462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_substitution, 4, 0, 0), + [5464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_substitution, 4, 0, 0), + [5466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__element, 1, 0, 0), + [5468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [5470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 2, 0, 15), + [5472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter_signature, 5, 0, 10), + [5474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter_signature, 5, 0, 10), + [5476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_formal_parameter, 1, 0, 6), + [5478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uri, 1, 0, 0), + [5480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), + [5482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [5484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 3, 0, 4), + [5486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 3, 0, 4), + [5488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__simple_formal_parameter, 1, 0, 6), + [5490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2074), + [5492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 1), + [5494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter_signature, 4, 0, 2), + [5496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter_signature, 4, 0, 2), + [5498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__late_builtin, 1, 0, 0), + [5500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__late_builtin, 1, 0, 0), + [5502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2055), + [5504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 1, 0, 0), + [5506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__string_literal_single_quotes_multiple_repeat1, 1, 0, 0), + [5508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 4, 0, 2), + [5510] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 4, 0, 2), + [5512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_substitution, 2, 0, 0), + [5514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_substitution, 2, 0, 0), + [5516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operator_signature, 5, 0, 0), + [5518] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_operator_signature, 5, 0, 0), + [5520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constructor_param, 5, 0, 0), + [5522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 3, 0, 3), + [5524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 3, 0, 3), + [5526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 7), + [5528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 0), + [5530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter_signature, 3, 0, 2), + [5532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter_signature, 3, 0, 2), + [5534] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_is_operator, 1, 0, 0), + [5536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_operator, 1, 0, 0), + [5538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_factory_constructor_signature_repeat1, 2, 0, 0), + [5540] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_factory_constructor_signature_repeat1, 2, 0, 0), SHIFT_REPEAT(3496), + [5543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter_signature, 4, 0, 10), + [5545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter_signature, 4, 0, 10), + [5547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_signature, 2, 0, 0), + [5549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 2, 0, 0), + [5551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_signature, 2, 0, 0), + [5553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_signature, 4, 0, 11), + [5555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_signature, 4, 0, 11), + [5557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_super_formal_parameter, 5, 0, 0), + [5559] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_formal_parameter, 5, 0, 0), + [5561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__native, 2, 0, 0), + [5563] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__native, 2, 0, 0), + [5565] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 1, 0, 0), + [5567] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_multiple_repeat1, 1, 0, 0), + [5569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 1, 0, 0), + [5571] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3463), + [5573] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2035), + [5575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(989), + [5577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_identifier_list, 1, 0, 0), + [5579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3496), + [5581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__type_not_void_list_repeat1, 2, 0, 0), + [5583] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__type_not_void_list_repeat1, 2, 0, 0), SHIFT_REPEAT(2094), + [5586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2721), + [5588] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2114), + [5590] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3189), + [5592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_identifier_list, 2, 0, 0), + [5594] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(2302), + [5597] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2956), + [5599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2098), + [5601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3205), + [5603] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2139), + [5605] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__identifier_list, 1, 0, 0), + [5607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void_list, 2, 0, 0), + [5609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2094), + [5611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1975), + [5613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2709), + [5615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_library_export_repeat1, 2, 0, 0), + [5617] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_library_export_repeat1, 2, 0, 0), SHIFT_REPEAT(3232), + [5620] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_not_void_list, 1, 0, 0), + [5622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_configuration_uri, 3, 0, 0), + [5624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [5626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [5628] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 2, 0, 60), + [5630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__identifier_list, 2, 0, 0), + [5632] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_switch_statement_case_repeat1, 2, 0, 0), SHIFT_REPEAT(3429), + [5635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_switch_statement_case_repeat1, 2, 0, 0), + [5637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_double_quotes_repeat1, 1, 0, 0), + [5639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 75), + [5641] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3334), + [5643] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__identifier_list_repeat1, 2, 0, 0), SHIFT_REPEAT(3349), + [5646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__identifier_list_repeat1, 2, 0, 0), + [5648] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2359), + [5650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3138), + [5652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [5654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_variable_definition, 1, 0, 6), + [5656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [5658] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2543), + [5660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_configurable_uri_repeat1, 1, 0, 0), + [5662] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2289), + [5664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2355), + [5666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2344), + [5668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__string_literal_single_quotes_repeat1, 1, 0, 0), + [5670] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(2335), + [5674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type_field, 1, 0, 0), + [5676] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2125), + [5678] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2676), + [5680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_named_parameter, 2, 0, 0), + [5682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [5684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), + [5686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3509), + [5688] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 1, 0, 0), REDUCE(sym__normal_formal_parameter, 2, 0, 0), + [5691] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__normal_formal_parameter, 1, 0, 6), REDUCE(sym__normal_formal_parameter, 2, 0, 15), + [5694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [5696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1789), + [5698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2308), + [5700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), + [5702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2112), + [5704] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_named_parameter, 3, 0, 0), + [5706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [5708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__guarded_pattern, 1, 0, 0), + [5710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [5712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 3, 0, 7), + [5714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2284), + [5716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_switch_block_repeat1, 1, 0, 0), + [5718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_switch_block_repeat1, 1, 0, 0), + [5720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3097), + [5722] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_is_operator, 2, 0, 0), + [5724] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_operator, 2, 0, 0), + [5726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spread_element, 2, 0, 0), + [5728] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_type_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1915), + [5731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_type_list_repeat1, 2, 0, 0), + [5733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 3, 0, 0), + [5735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2301), + [5737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_named_parameter, 1, 0, 0), + [5739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [5741] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3279), + [5743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_element, 7, 0, 101), + [5745] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spread_element, 3, 0, 0), + [5747] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat1, 2, 0, 0), + [5749] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_enum_body_repeat1, 2, 0, 0), SHIFT_REPEAT(2549), + [5752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_superclass, 2, 0, 0), + [5754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [5756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2630), + [5758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_element, 4, 0, 56), + [5760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2322), + [5762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2631), + [5764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_normal_parameter_type, 1, 0, 0), + [5766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [5768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3309), + [5770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_normal_parameter_type, 2, 0, 0), + [5772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_element, 9, 0, 113), + [5774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_element, 3, 0, 37), + [5776] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__final_or_const, 1, 0, 0), + [5778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__final_or_const, 1, 0, 0), + [5780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 1), + [5782] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__typedef, 1, 0, 0), + [5784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__typedef, 1, 0, 0), + [5786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_element, 5, 0, 72), + [5788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [5790] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_as_operator, 1, 0, 0), + [5792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_as_operator, 1, 0, 0), + [5794] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3051), + [5796] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__implements, 1, 0, 0), + [5798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__implements, 1, 0, 0), + [5800] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_application, 2, 0, 0), + [5802] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_literal_repeat1, 2, 0, 0), + [5804] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(156), + [5807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pair, 3, 0, 55), + [5809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_element, 7, 0, 102), + [5811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [5813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1707), + [5815] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3629), + [5817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [5819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [5821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_variable_definition, 4, 0, 41), + [5823] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_initialized_identifier_list_repeat1, 2, 0, 0), SHIFT_REPEAT(3138), + [5826] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_initialized_identifier_list_repeat1, 2, 0, 0), + [5828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), + [5830] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3061), + [5832] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(3171), + [5835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_parameter_types_repeat1, 2, 0, 0), + [5837] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_parameter_types_repeat1, 2, 0, 0), SHIFT_REPEAT(1832), + [5840] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_static_final_declaration_list_repeat1, 2, 0, 0), SHIFT_REPEAT(3124), + [5843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_static_final_declaration_list_repeat1, 2, 0, 0), + [5845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2101), + [5847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2085), + [5849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1667), + [5851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1865), + [5853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 4, 0, 3), + [5855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2532), + [5857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3371), + [5859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(759), + [5861] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3303), + [5863] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_formal_parameter, 1, 0, 0), + [5865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [5867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), + [5869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3410), + [5871] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_arguments_repeat1, 2, 0, 0), SHIFT_REPEAT(2085), + [5874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_arguments_repeat1, 2, 0, 0), + [5876] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3053), + [5878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1817), + [5880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2558), + [5882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1856), + [5884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2733), + [5886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2311), + [5888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1526), + [5890] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__var_or_type, 2, 0, 0), + [5892] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__normal_formal_parameters, 2, 0, 0), SHIFT(986), + [5895] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameters, 2, 0, 0), + [5897] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [5899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1857), + [5901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [5903] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(172), + [5906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__argument_list_repeat1, 2, 0, 0), + [5908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2132), + [5910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [5912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [5914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_combinator, 2, 0, 0), + [5916] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3079), + [5918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1860), + [5920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), + [5922] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3095), + [5924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 3, 0, 2), + [5926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2727), + [5928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [5930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3385), + [5932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1818), + [5934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1849), + [5936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3442), + [5938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1861), + [5940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [5942] = {.entry = {.count = 1, .reusable = false}}, SHIFT(254), + [5944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2614), + [5946] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2618), + [5948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3124), + [5950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_static_final_declaration_list, 2, 0, 0), + [5952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1380), + [5954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3518), + [5956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [5958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [5960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [5962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [5964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), + [5966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [5968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [5970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1848), + [5972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_variable_definition, 2, 0, 6), + [5974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__named_formal_parameters_repeat1, 2, 0, 0), + [5976] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__named_formal_parameters_repeat1, 2, 0, 0), SHIFT_REPEAT(815), + [5979] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat1, 2, 0, 76), SHIFT_REPEAT(246), + [5982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat1, 2, 0, 76), + [5984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [5986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), + [5988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), + [5990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 78), + [5992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [5994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [5996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [5998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2457), + [6000] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__optional_postional_formal_parameters_repeat1, 2, 0, 0), SHIFT_REPEAT(876), + [6003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__optional_postional_formal_parameters_repeat1, 2, 0, 0), + [6005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 80), + [6007] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 81), + [6009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3171), + [6011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3122), + [6013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1301), + [6015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2994), + [6017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [6019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [6021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2383), + [6023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [6025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [6027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [6029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2248), + [6031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [6033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1905), + [6035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), + [6037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [6039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [6041] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_initializers_repeat1, 2, 0, 0), SHIFT_REPEAT(2248), + [6044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(406), + [6046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3209), + [6048] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 5, 0, 3), + [6050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 5, 0, 2), + [6052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_static_final_declaration_list, 1, 0, 0), + [6054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 2, 0, 0), + [6056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2701), + [6058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2734), + [6060] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_type_repeat2, 2, 0, 0), + [6062] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_type_repeat2, 2, 0, 0), SHIFT_REPEAT(1913), + [6065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1850), + [6067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [6069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [6071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1868), + [6073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1634), + [6075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [6077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [6079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1869), + [6081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [6083] = {.entry = {.count = 1, .reusable = false}}, SHIFT(257), + [6085] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2518), + [6087] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2519), + [6089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [6091] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3076), + [6093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [6095] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 2, 0, 3), + [6097] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_switch_expression_repeat1, 2, 0, 0), + [6099] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_switch_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(421), + [6102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2755), + [6104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2416), + [6106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [6108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), + [6110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1594), + [6112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [6114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [6116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__guarded_pattern, 3, 0, 0), + [6118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3193), + [6120] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1948), + [6123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_type_repeat1, 2, 0, 0), + [6125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [6127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2433), + [6129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), + [6131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [6133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [6135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [6137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1286), + [6139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 89), + [6141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 90), + [6143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [6145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__argument_list, 1, 0, 0), + [6147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3175), + [6149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1098), + [6151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 93), + [6153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [6155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [6157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [6159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [6161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 94), + [6163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403), + [6165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 95), + [6167] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat2, 2, 0, 96), SHIFT_REPEAT(203), + [6170] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat2, 2, 0, 96), + [6172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [6174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [6176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 97), + [6178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3458), + [6180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1851), + [6182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [6184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(385), + [6186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1871), + [6188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [6190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1872), + [6192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), + [6194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2513), + [6196] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2523), + [6198] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), REDUCE(sym__final_var_or_type, 1, 0, 0), SHIFT(2510), + [6202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), + [6204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2076), + [6206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), + [6208] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameters_repeat1, 2, 0, 0), SHIFT_REPEAT(2311), + [6211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameters_repeat1, 2, 0, 0), + [6213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), + [6215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1703), + [6217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), + [6219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [6221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [6223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [6225] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(2291), + [6228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3160), + [6230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_identifier_list, 1, 0, 0), + [6232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [6234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), + [6236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1312), + [6238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_constant, 6, 0, 2), + [6240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1706), + [6242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [6244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [6246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [6248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), + [6250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [6252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), + [6254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [6256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [6258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [6260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [6262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [6264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [6266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1875), + [6268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1556), + [6270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_pattern_repeat1, 2, 0, 0), + [6272] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(187), + [6275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), + [6277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [6279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [6281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), + [6283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [6285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1876), + [6287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1852), + [6289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3065), + [6291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1504), + [6293] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(2510), + [6296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), + [6298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1714), + [6300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1527), + [6302] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(415), + [6305] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 0), + [6307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1474), + [6309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3264), + [6311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [6313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2066), + [6315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), + [6317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [6319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [6321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [6323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(761), + [6325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1878), + [6327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), + [6329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2116), + [6331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1879), + [6333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [6335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), + [6337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [6339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1055), + [6341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [6343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), + [6345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), + [6347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1650), + [6349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1719), + [6351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [6353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 103), + [6355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 104), + [6357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), + [6359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), + [6361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), + [6363] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2624), + [6365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2625), + [6367] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 106), + [6369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), + [6371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), + [6373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 107), + [6375] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 5, 0, 108), + [6377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [6379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__record_literal_no_const_repeat1, 2, 0, 0), SHIFT_REPEAT(185), + [6382] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__record_literal_no_const_repeat1, 2, 0, 0), + [6384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3517), + [6386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1880), + [6388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_library_export_repeat1, 1, 0, 0), + [6390] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(420), + [6393] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_pattern_repeat1, 2, 0, 0), + [6395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1881), + [6397] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__normal_formal_parameters, 1, 0, 0), SHIFT(986), + [6400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__normal_formal_parameters, 1, 0, 0), + [6402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1882), + [6404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1883), + [6406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(950), + [6408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [6410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1884), + [6412] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3280), + [6414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3331), + [6416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1885), + [6418] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__normal_formal_parameters_repeat1, 2, 0, 0), SHIFT_REPEAT(986), + [6421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__normal_formal_parameters_repeat1, 2, 0, 0), + [6423] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_switch_statement_case_repeat1, 1, 0, 0), + [6425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1886), + [6427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [6429] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 3, 0, 0), + [6431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [6433] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 6, 0, 110), + [6435] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 6, 0, 111), + [6437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1887), + [6439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 6, 0, 112), + [6441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1888), + [6443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1889), + [6445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), + [6447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), + [6449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3490), + [6451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1890), + [6453] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixins, 2, 0, 0), + [6455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1891), + [6457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1892), + [6459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1893), + [6461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1894), + [6463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3354), + [6465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1895), + [6467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1896), + [6469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 7, 0, 114), + [6471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1833), + [6473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1898), + [6475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1899), + [6477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3397), + [6479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1900), + [6481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1901), + [6483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [6485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [6487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1902), + [6489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [6491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1903), + [6493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1904), + [6495] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__final_const_var_or_type, 2, 0, 0), REDUCE(sym__final_var_or_type, 2, 0, 0), + [6498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_variable_definition, 3, 0, 41), + [6500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), + [6502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2666), + [6504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3060), + [6506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3459), + [6508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_identifier_list, 2, 0, 0), + [6510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2093), + [6512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [6514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3606), + [6516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirecting_factory_constructor_signature, 5, 0, 0), + [6518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), + [6520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [6522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [6524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1662), + [6526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [6528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [6530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [6532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 2, 0, 0), + [6534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_superclass, 1, 0, 0), + [6536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field, 2, 0, 0), + [6538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [6540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1219), + [6542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_base, 1, 0, 0), + [6544] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_field, 1, 0, 0), SHIFT(3534), + [6547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), + [6549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression_case, 3, 0, 0), + [6551] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_static_final_declaration, 3, 0, 0), + [6553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [6555] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument, 1, 0, 0), + [6557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_parameter_type, 1, 0, 0), + [6559] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 4, 0, 7), + [6561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_representation_declaration, 4, 0, 63), + [6563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 4, 0, 0), + [6565] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2292), + [6567] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3454), + [6569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type_named_field, 2, 0, 0), + [6571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [6573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat2, 2, 0, 60), + [6575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [6577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2454), + [6579] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__any_argument, 1, 0, 0), + [6581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_named_parameter, 4, 0, 0), + [6583] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bound, 2, 0, 0), + [6585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 3, 0, 1), + [6587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [6589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), + [6591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [6593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [6595] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_field, 1, 0, 0), SHIFT(3548), + [6598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1166), + [6600] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type_named_field, 1, 0, 0), + [6602] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_field, 1, 0, 0), SHIFT(3388), + [6605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(572), + [6607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2120), + [6609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_representation_declaration, 6, 0, 98), + [6611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_mixin, 1, 0, 0), + [6613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3488), + [6615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirecting_factory_constructor_signature, 6, 0, 0), + [6617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2131), + [6619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__map_pattern_entry, 3, 0, 0), + [6621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__for_loop_parts_repeat1, 2, 0, 74), + [6623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2153), + [6625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [6627] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pattern_field, 1, 0, 0), + [6629] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__pattern_field, 1, 0, 0), SHIFT(2046), + [6632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [6634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(427), + [6636] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_field, 1, 0, 0), SHIFT(3413), + [6639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uri_test, 1, 0, 0), + [6641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1947), + [6643] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_formal_parameter, 3, 0, 0), + [6645] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2590), + [6647] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3627), + [6649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2736), + [6651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pattern_field, 2, 0, 0), + [6653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1301), + [6655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3560), + [6657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3563), + [6659] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_parameter_type, 2, 0, 0), + [6661] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2575), + [6663] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3588), + [6665] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2315), + [6667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2191), + [6669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2512), + [6671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2030), + [6673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [6675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [6677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2828), + [6679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_parameter_type, 3, 0, 0), + [6681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pattern_field, 3, 0, 0), + [6683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3361), + [6685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2425), + [6687] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field, 1, 0, 0), + [6689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [6691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2572), + [6693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [6695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [6697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [6699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_representation_declaration, 7, 0, 109), + [6701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3553), + [6703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirecting_factory_constructor_signature, 7, 0, 0), + [6705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [6707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [6709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [6711] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__list_pattern_element, 1, 0, 0), + [6713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2874), + [6715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [6717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), + [6719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_initialized_identifier, 3, 0, 0), + [6721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [6723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [6725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), + [6727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [6729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [6731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [6733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1400), + [6735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [6737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [6739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [6741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [6743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [6745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [6747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [6749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [6751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [6753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [6755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [6757] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_constructor_signature, 3, 0, 0), + [6759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interfaces, 2, 0, 0), + [6761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1916), + [6763] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2310), + [6765] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3372), + [6767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [6769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), + [6771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rest_pattern, 2, 0, 0), + [6773] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_representation_declaration, 5, 0, 84), + [6775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2307), + [6777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3561), + [6779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_superclass, 3, 0, 0), + [6781] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__default_named_parameter, 5, 0, 0), + [6783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_constructor_signature, 5, 0, 0), + [6785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [6787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [6789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2289), + [6791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [6793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1558), + [6795] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3636), + [6797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2947), + [6799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__class_modifiers, 2, 0, 0), + [6801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 41), + [6803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), + [6805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__class_modifiers, 1, 0, 0), + [6807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), + [6809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), + [6811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1665), + [6813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__optional_postional_formal_parameters, 4, 0, 0), + [6815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2170), + [6817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__var_or_type, 1, 0, 0), SHIFT(2537), + [6820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), + [6822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), + [6824] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 5, 0, 0), + [6826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [6828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2655), + [6830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1512), + [6832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3614), + [6834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3495), + [6836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2410), + [6838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1160), + [6840] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirection, 3, 0, 0), + [6842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [6844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2668), + [6846] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [6848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2450), + [6850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1674), + [6852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1459), + [6854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), + [6856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [6858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), + [6860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2577), + [6862] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 4, 0, 0), + [6864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1542), + [6866] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_formal_parameters, 3, 0, 0), + [6868] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__mixin_class_modifiers, 3, 0, 0), + [6870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [6872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [6874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [6876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [6878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), + [6880] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_mixin_application, 3, 0, 0), + [6882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), + [6884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), + [6886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1546), + [6888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), + [6890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_parameter_types, 3, 0, 0), + [6892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [6894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), + [6896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1751), + [6898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(624), + [6900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [6902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1648), + [6904] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__as, 1, 0, 0), + [6906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2361), + [6908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1118), + [6910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3565), + [6912] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3639), + [6914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2105), + [6916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1147), + [6918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), + [6920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), + [6922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2124), + [6924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [6926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [6928] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__optional_postional_formal_parameters, 3, 0, 0), + [6930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), + [6932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [6934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), + [6936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), + [6938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [6940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), + [6942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2359), + [6944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2082), + [6946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2157), + [6948] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nullable_selector, 1, 0, 0), + [6950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2109), + [6952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), + [6954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), + [6956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [6958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), + [6960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1777), + [6962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), + [6964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(600), + [6966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2166), + [6968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__final_var_or_type, 2, 0, 0), + [6970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2371), + [6972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2370), + [6974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2621), + [6976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2373), + [6978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [6980] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_optional_positional_parameter_types, 3, 0, 0), + [6982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(653), + [6984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [6986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), + [6988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(603), + [6990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(578), + [6992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [6994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [6996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), + [6998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), + [7000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3372), + [7002] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__mixin_class_modifiers, 2, 0, 0), + [7004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1174), + [7006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1173), + [7008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), + [7010] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__class_modifiers, 3, 0, 0), + [7012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), + [7014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), + [7016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [7018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [7020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), + [7022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), + [7024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(650), + [7026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2151), + [7028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1807), + [7030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [7032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), + [7034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [7036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3568), + [7038] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_parameter_types, 4, 0, 0), + [7040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), + [7042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [7044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3479), + [7046] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_parameters, 5, 0, 0), + [7048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [7050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_optional_formal_parameters, 1, 0, 0), + [7052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2306), + [7054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3116), + [7056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2159), + [7058] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_formal_parameters, 5, 0, 0), + [7060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(574), + [7062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3543), + [7064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3551), + [7066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sealed, 1, 0, 0), + [7068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), + [7070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2224), + [7072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2137), + [7074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2594), + [7076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2613), + [7078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [7080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2497), + [7082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2260), + [7084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2522), + [7086] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__factory, 1, 0, 0), + [7088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2160), + [7090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), + [7092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [7094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3602), + [7096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [7098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1651), + [7100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1682), + [7102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [7104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2077), + [7106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3571), + [7108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), + [7110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2506), + [7112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(555), + [7114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(554), + [7116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1209), + [7118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), + [7120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), + [7122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [7124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [7126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3484), + [7128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), + [7130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__deferred, 1, 0, 0), + [7132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(617), + [7134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), + [7136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3503), + [7138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2483), + [7140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3242), + [7142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [7144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3581), + [7146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_optional_positional_parameter_types, 4, 0, 0), + [7148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__mixin_class_modifiers, 4, 0, 0), + [7150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2574), + [7152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1418), + [7154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2274), + [7156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2803), + [7158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), + [7160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirecting_factory_constructor_signature, 8, 0, 0), + [7162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3573), + [7164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), + [7166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2312), + [7168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3478), + [7170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3198), + [7172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1115), + [7174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_parameters, 3, 0, 0), + [7176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), + [7178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2138), + [7180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [7182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), + [7184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3305), + [7186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [7188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 3, 0, 0), + [7190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3431), + [7192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1793), + [7194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirecting_factory_constructor_signature, 9, 0, 0), + [7196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1185), + [7198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [7200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_clause, 2, 0, 0), + [7202] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uri_test, 3, 0, 0), + [7204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_optional_parameter_types, 1, 0, 0), + [7206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_parameter_types, 5, 0, 0), + [7208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3325), + [7210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), + [7212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), + [7214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2589), + [7216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1313), + [7218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_optional_positional_parameter_types, 5, 0, 0), + [7220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3567), + [7222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2590), + [7224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_redirection, 5, 0, 0), + [7226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [7228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1699), + [7230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [7232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__bitwise_operator, 1, 0, 0), + [7234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [7236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 3, 0, 73), + [7238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__final_var_or_type, 1, 0, 0), + [7240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_operator, 1, 0, 0), + [7242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2152), + [7244] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bitwise_operator, 1, 0, 0), + [7246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [7248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__dot_identifier, 2, 19, 0), + [7250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2350), + [7252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3239), + [7254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(647), + [7256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3504), + [7258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3539), + [7260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), + [7262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), + [7264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [7266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3637), + [7268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3161), + [7270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3483), + [7272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__named_formal_parameters, 4, 0, 0), + [7274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [7276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [7278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(604), + [7280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [7282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1632), + [7284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), + [7286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface, 1, 0, 0), + [7288] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__for_loop_parts, 4, 0, 92), + [7290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2591), + [7292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [7294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1962), + [7296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [7298] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern_variable_declaration, 4, 0, 0), + [7300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1923), + [7302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3613), + [7304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__optional_postional_formal_parameters, 5, 0, 0), + [7306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 1, 0, 0), + [7308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_documentation_comment, 2, 0, 0), + [7310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3, 0, 0), + [7312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_documentation_comment, 1, 0, 0), + [7314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2, 0, 0), +}; + +enum ts_external_scanner_symbol_identifiers { + ts_external_token__template_chars_double = 0, + ts_external_token__template_chars_single = 1, + ts_external_token__template_chars_double_single = 2, + ts_external_token__template_chars_single_single = 3, + ts_external_token__template_chars_raw_slash = 4, + ts_external_token__block_comment = 5, + ts_external_token__documentation_block_comment = 6, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token__template_chars_double] = sym__template_chars_double, + [ts_external_token__template_chars_single] = sym__template_chars_single, + [ts_external_token__template_chars_double_single] = sym__template_chars_double_single, + [ts_external_token__template_chars_single_single] = sym__template_chars_single_single, + [ts_external_token__template_chars_raw_slash] = sym__template_chars_raw_slash, + [ts_external_token__block_comment] = sym__block_comment, + [ts_external_token__documentation_block_comment] = sym__documentation_block_comment, +}; + +static const bool ts_external_scanner_states[11][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token__template_chars_double] = true, + [ts_external_token__template_chars_single] = true, + [ts_external_token__template_chars_double_single] = true, + [ts_external_token__template_chars_single_single] = true, + [ts_external_token__template_chars_raw_slash] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [2] = { + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [3] = { + [ts_external_token__template_chars_double] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [4] = { + [ts_external_token__template_chars_single] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [5] = { + [ts_external_token__template_chars_double_single] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [6] = { + [ts_external_token__template_chars_single_single] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [7] = { + [ts_external_token__template_chars_double] = true, + [ts_external_token__template_chars_raw_slash] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [8] = { + [ts_external_token__template_chars_single] = true, + [ts_external_token__template_chars_raw_slash] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [9] = { + [ts_external_token__template_chars_double_single] = true, + [ts_external_token__template_chars_raw_slash] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, + [10] = { + [ts_external_token__template_chars_single_single] = true, + [ts_external_token__template_chars_raw_slash] = true, + [ts_external_token__block_comment] = true, + [ts_external_token__documentation_block_comment] = true, + }, +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_dart_external_scanner_create(void); +void tree_sitter_dart_external_scanner_destroy(void *); +bool tree_sitter_dart_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_dart_external_scanner_serialize(void *, char *); +void tree_sitter_dart_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_dart(void) { + static const TSLanguage language = { + .abi_version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .supertype_count = SUPERTYPE_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .supertype_map_slices = ts_supertype_map_slices, + .supertype_map_entries = ts_supertype_map_entries, + .supertype_symbols = ts_supertype_symbols, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = (const void*)ts_lex_modes, + .lex_fn = ts_lex, + .keyword_lex_fn = ts_lex_keywords, + .keyword_capture_token = sym_identifier, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_dart_external_scanner_create, + tree_sitter_dart_external_scanner_destroy, + tree_sitter_dart_external_scanner_scan, + tree_sitter_dart_external_scanner_serialize, + tree_sitter_dart_external_scanner_deserialize, + }, + .primary_state_ids = ts_primary_state_ids, + .name = "dart", + .max_reserved_word_set_size = 0, + .metadata = { + .major_version = 1, + .minor_version = 0, + .patch_version = 0, + }, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/codegraph-kernel/grammars/dart/scanner.c b/codegraph-kernel/grammars/dart/scanner.c new file mode 100644 index 0000000..e736bc9 --- /dev/null +++ b/codegraph-kernel/grammars/dart/scanner.c @@ -0,0 +1,130 @@ +#include "tree_sitter/parser.h" +#include + +enum TokenType { + TEMPLATE_CHARS_SINGLE, + TEMPLATE_CHARS_DOUBLE, + TEMPLATE_CHARS_SINGLE_SINGLE, + TEMPLATE_CHARS_DOUBLE_SINGLE, + TEMPLATE_CHARS_RAW_SLASH, + BLOCK_COMMENT, + DOCUMENTATION_BLOCK_COMMENT, +}; + +void *tree_sitter_dart_external_scanner_create() { return NULL; } +void tree_sitter_dart_external_scanner_destroy(void *p) {} +void tree_sitter_dart_external_scanner_reset(void *p) {} +unsigned tree_sitter_dart_external_scanner_serialize(void *p, char *buffer) { return 0; } +void tree_sitter_dart_external_scanner_deserialize(void *p, const char *b, unsigned n) {} + +static void advance(TSLexer *lexer) { lexer->advance(lexer, false); } +static void skip(TSLexer *lexer) { lexer->advance(lexer, true); } + +static bool scan_multiline_comments(TSLexer *lexer) { + + bool documentation_comment = false; + advance(lexer); + if (lexer->lookahead != '*') return false; + advance(lexer); + if (lexer->lookahead == '*') documentation_comment = true; + + bool after_star = false; + unsigned nesting_depth = 1; + for (;;) { + switch (lexer->lookahead) { + case '\0': + return false; + case '*': + advance(lexer); + after_star = true; + break; + case '/': + if (after_star) { + advance(lexer); + after_star = false; + nesting_depth--; + if (nesting_depth == 0) { + if (!documentation_comment) { + lexer->result_symbol = BLOCK_COMMENT; + } else { + lexer->result_symbol = DOCUMENTATION_BLOCK_COMMENT; + } + return true; + } + } else { + advance(lexer); + after_star = false; + if (lexer->lookahead == '*') { + nesting_depth++; + advance(lexer); + } + } + break; + default: + advance(lexer); + after_star = false; + break; + } + } + return false; +} + + +static bool scan_templates(TSLexer *lexer, const bool *valid_symbols) { + if(valid_symbols[TEMPLATE_CHARS_DOUBLE]) { + lexer->result_symbol = TEMPLATE_CHARS_DOUBLE; + } else if (valid_symbols[TEMPLATE_CHARS_SINGLE]) { + lexer->result_symbol = TEMPLATE_CHARS_SINGLE; + } else if (valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE]) { + lexer->result_symbol = TEMPLATE_CHARS_SINGLE_SINGLE; + } else { + lexer->result_symbol = TEMPLATE_CHARS_DOUBLE_SINGLE; + } + for (bool has_content = false;; has_content = true) { + lexer->mark_end(lexer); + switch (lexer->lookahead) { + case '\'': + case '"': + return has_content; + case '\n': + if (valid_symbols[TEMPLATE_CHARS_DOUBLE_SINGLE] || valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE]) return false; + advance(lexer); + break; + case '\0': + return false; + case '$': + return has_content; + case '\\': + if (valid_symbols[TEMPLATE_CHARS_RAW_SLASH]) { + lexer->result_symbol = TEMPLATE_CHARS_RAW_SLASH; + advance(lexer); + } else { + return has_content; + } + break; + default: + advance(lexer); + } + } + return true; +} + + + +bool tree_sitter_dart_external_scanner_scan(void *payload, TSLexer *lexer, + const bool *valid_symbols) { + if ( + valid_symbols[TEMPLATE_CHARS_DOUBLE] || + valid_symbols[TEMPLATE_CHARS_SINGLE] || + valid_symbols[TEMPLATE_CHARS_DOUBLE_SINGLE] || + valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE] + ) { + return scan_templates(lexer, valid_symbols); + } + while (iswspace(lexer->lookahead)) lexer->advance(lexer, true); + + if (lexer->lookahead == '/') { + return scan_multiline_comments(lexer); + } + return false; +} diff --git a/codegraph-kernel/grammars/dart/tree_sitter/alloc.h b/codegraph-kernel/grammars/dart/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/codegraph-kernel/grammars/dart/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/codegraph-kernel/grammars/dart/tree_sitter/array.h b/codegraph-kernel/grammars/dart/tree_sitter/array.h new file mode 100644 index 0000000..a17a574 --- /dev/null +++ b/codegraph-kernel/grammars/dart/tree_sitter/array.h @@ -0,0 +1,291 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + _array__reserve((Array *)(self), array_elem_size(self), new_capacity) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) _array__delete((Array *)(self)) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + (_array__grow((Array *)(self), 1, array_elem_size(self)), \ + (self)->contents[(self)->size++] = (element)) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + _array__grow((Array *)(self), count, array_elem_size(self)); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), (self)->size, \ + 0, count, contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + _array__splice( \ + (Array *)(self), array_elem_size(self), _index, \ + old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element)) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((Array *)(self), array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self)) + +/// Swap one array with another +#define array_swap(self, other) \ + _array__swap((Array *)(self), (Array *)(other)) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +typedef Array(void) Array; + +/// This is not what you're looking for, see `array_delete`. +static inline void _array__delete(Array *self) { + if (self->contents) { + ts_free(self->contents); + self->contents = NULL; + self->size = 0; + self->capacity = 0; + } +} + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(Array *self, size_t element_size, + uint32_t index) { + assert(index < self->size); + char *contents = (char *)self->contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (self->size - index - 1) * element_size); + self->size--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) { + if (new_capacity > self->capacity) { + if (self->contents) { + self->contents = ts_realloc(self->contents, new_capacity * element_size); + } else { + self->contents = ts_malloc(new_capacity * element_size); + } + self->capacity = new_capacity; + } +} + +/// This is not what you're looking for, see `array_assign`. +static inline void _array__assign(Array *self, const Array *other, size_t element_size) { + _array__reserve(self, element_size, other->size); + self->size = other->size; + memcpy(self->contents, other->contents, self->size * element_size); +} + +/// This is not what you're looking for, see `array_swap`. +static inline void _array__swap(Array *self, Array *other) { + Array swap = *other; + *other = *self; + *self = swap; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void _array__grow(Array *self, uint32_t count, size_t element_size) { + uint32_t new_size = self->size + count; + if (new_size > self->capacity) { + uint32_t new_capacity = self->capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + _array__reserve(self, element_size, new_capacity); + } +} + +/// This is not what you're looking for, see `array_splice`. +static inline void _array__splice(Array *self, size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = self->size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= self->size); + + _array__reserve(self, element_size, new_size); + + char *contents = (char *)self->contents; + if (self->size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (self->size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + self->size += new_count - old_count; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/codegraph-kernel/grammars/dart/tree_sitter/parser.h b/codegraph-kernel/grammars/dart/tree_sitter/parser.h new file mode 100644 index 0000000..858107d --- /dev/null +++ b/codegraph-kernel/grammars/dart/tree_sitter/parser.h @@ -0,0 +1,286 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +typedef struct TSLanguageMetadata { + uint8_t major_version; + uint8_t minor_version; + uint8_t patch_version; +} TSLanguageMetadata; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +// Used to index the field and supertype maps. +typedef struct { + uint16_t index; + uint16_t length; +} TSMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; + uint16_t reserved_word_set_id; +} TSLexerMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t abi_version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexerMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; + const char *name; + const TSSymbol *reserved_words; + uint16_t max_reserved_word_set_size; + uint32_t supertype_count; + const TSSymbol *supertype_symbols; + const TSMapSlice *supertype_map_slices; + const TSSymbol *supertype_map_entries; + TSLanguageMetadata metadata; +}; + +static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + const TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + const TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/codegraph-kernel/src/dart.rs b/codegraph-kernel/src/dart.rs new file mode 100644 index 0000000..a0df27a --- /dev/null +++ b/codegraph-kernel/src/dart.rs @@ -0,0 +1,1547 @@ +//! Dart extraction — a faithful Rust port of the dart paths of +//! `TreeSitterExtractor` (src/extraction/tree-sitter.ts) plus +//! languages/dart.ts. +//! +//! Same porting contract as the other walkers: behavior parity, bug-for-bug. +//! The authoritative quirk list is docs/design/dart-kernel-port-checklist.md. +//! The center of gravity is THE SIBLING-BODY DOUBLE-WALK: dart attaches every +//! function/method body as a NEXT SIBLING of its signature node, and the TS +//! walkers consume the body TWICE — once via resolveBody (attributed to the +//! function/method) and once via the enclosing generic walk (attributed to +//! the file/class). The deterministic result — duplicate local-function +//! nodes with the SAME id under different parents, duplicated +//! calls/instantiates refs, file/class-attributed fn-ref twins — must be +//! reproduced byte-for-byte in the observed interleave; a "helpful" dedupe +//! breaks parity. Other load-bearing oddities preserved on purpose: +//! callTypes is EMPTY (all call refs ride extractBareCall's selector +//! walking in the body walker — cascades are invisible, `?.` encodes like +//! `.`); `ConfigT.load()` double-emits (calls + a static-member references +//! ref — no callee-of-call skip in the dart branch); operator methods mint +//! `method ""`; the unnamed constructor is skipped +//! (isMisparsedFunction) while named ctors/factories are named by the CTOR +//! name with the class as returnType; instance fields mint NO nodes (only +//! static_final_declaration → constant, via the hook); prefixed return +//! types keep the PREFIX (`other.OtherClass f()` → returnType `other` — +//! bug, preserved); enum `with` mixins emit nothing while enum `implements` +//! works; deferred imports are invisible; named-argument callbacks are NOT +//! fn-ref-captured; `async*`/`sync*` are NOT async. Positions in UTF-16 +//! code units. Files with parse errors defer to wasm (3.4–20.7% both-arm +//! incidence — empty object patterns and unnamed `library;` dominate). + +use crate::buffers::{ + build_meta, edge_kind_index, node_kind_index, Arena, BoolFlags, EdgeRow, EmitOut, NodeRow, + RefRow, StrRef, Tables, FLAG_IS_ASYNC, FLAG_IS_EXPORTED, FLAG_IS_STATIC, FUNCTION_REF_CODE, + NONE, NONE_STR, +}; +use crate::docstring::preceding_docstring; +use crate::ids; +use crate::textutil as util; +use regex::Regex; +use std::collections::{HashMap, HashSet}; +use std::sync::OnceLock; +use tree_sitter::{Node, Parser}; + +const MAX_VALUE_REF_NODES: usize = 20_000; + +/// NAME_STOPLIST (function-ref.ts). +fn is_stoplisted(name: &str) -> bool { + matches!( + name, + "this" | "self" | "super" | "null" | "nil" | "true" | "false" | "undefined" | "new" + | "NULL" | "nullptr" | "None" + ) +} + +/// BUILTIN_TYPES (tree-sitter.ts:5768-5782). +fn is_builtin_type(name: &str) -> bool { + matches!( + name, + "string" | "number" | "boolean" | "void" | "null" | "undefined" | "never" | "any" + | "unknown" | "object" | "symbol" | "bigint" | "true" | "false" + | "str" | "bool" | "i8" | "i16" | "i32" | "i64" | "i128" | "isize" + | "u8" | "u16" | "u32" | "u64" | "u128" | "usize" | "f32" | "f64" | "char" + | "int" | "long" | "short" | "byte" | "float" | "double" + | "int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" + | "float32" | "float64" | "complex64" | "complex128" | "rune" | "error" + | "Int" | "Long" | "Short" | "Byte" | "Float" | "Double" | "Boolean" | "Char" + | "Unit" | "String" | "Any" | "AnyRef" | "AnyVal" | "Nothing" | "Null" + ) +} + +/// extractDartReturnType's simple-name gate + the static-member receiver gate. +fn simple_type_name_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"^[A-Za-z_]\w*$").unwrap()) +} +fn cap_ident_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"^[A-Z][A-Za-z0-9_]*$").unwrap()) +} +/// The chained-call re-encode gate (`/^[A-Z]/`). +fn starts_upper_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"^[A-Z]").unwrap()) +} +/// extractDartReturnType's `<...>` strip (`/<[^>]*>/g`). +fn angle_args_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"<[^>]*>").unwrap()) +} + +struct Scope { + row: u32, + kind: &'static str, + name: String, +} + +struct Cand { + from: u32, + name: String, + line: u32, + column_byte: usize, + row: usize, +} + +struct ValueScope<'t> { + row: u32, + node: Node<'t>, + name: String, +} + +#[derive(Default)] +struct Extra { + docstring: Option, + signature: Option, + /// 0 = absent; 1 public, 2 private. + visibility: u8, + is_async: Option, + is_static: Option, + return_type: Option, + /// resolveBody-driven endLine extension (LIVE for dart sibling bodies). + end_line_override: Option, +} + +pub struct Walker<'t> { + src: &'t str, + file_path: &'t str, + line_starts: Vec, + arena: Arena, + tables: Tables, + stack: Vec, + node_ids: Vec, + defined_fn_names: HashSet, + imported_names: HashSet, + fn_ref_cands: Vec, + fs_values: HashMap, + fs_value_counts: HashMap, + value_scopes: Vec>, +} + +pub fn extract(file_path: &str, source: &str) -> Result { + let grammar = crate::langs::grammar_for("dart").ok_or("no dart grammar")?; + let t0 = std::time::Instant::now(); + let mut parser = Parser::new(); + parser + .set_language(&grammar) + .map_err(|e| format!("set_language(dart) failed: {e}"))?; + let tree = parser + .parse(source, None) + .ok_or_else(|| "parser returned null tree".to_string())?; + if tree.root_node().has_error() { + return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string()); + } + + let mut w = Walker { + src: source, + file_path, + line_starts: util::line_starts(source), + arena: Arena::default(), + tables: Tables::default(), + stack: Vec::new(), + node_ids: Vec::new(), + defined_fn_names: HashSet::new(), + imported_names: HashSet::new(), + fn_ref_cands: Vec::new(), + fs_values: HashMap::new(), + fs_value_counts: HashMap::new(), + value_scopes: Vec::new(), + }; + + // File node (tree-sitter.ts:508-521). + let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1; + let base_name = file_path.rsplit(['/', '\\']).next().unwrap_or(file_path); + let mut flags = BoolFlags::default(); + flags.set(FLAG_IS_EXPORTED, false); + let file_id = w.arena.put(&ids::file_node_id(file_path)); + let name_ref = w.arena.put(base_name); + let qn_ref = w.arena.put(file_path); + w.tables.push_node(&NodeRow { + kind: node_kind_index("file").unwrap(), + visibility: 0, + flags, + start_line: 1, + end_line: line_count, + start_column: 0, + end_column: 0, + name: name_ref, + qualified_name: qn_ref, + id: file_id, + docstring: NONE_STR, + signature: NONE_STR, + decorators: NONE_STR, + type_parameters: NONE_STR, + return_type: NONE_STR, + extra_json: NONE_STR, + }); + w.node_ids.push(ids::file_node_id(file_path)); + w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() }); + + w.visit(tree.root_node()); + w.flush_fn_ref_candidates(); + w.flush_value_refs(tree.root_node()); + w.stack.pop(); + + let duration_ms = t0.elapsed().as_secs_f64() * 1000.0; + let meta = build_meta(&w.tables, w.arena.len(), NONE_STR, duration_ms); + Ok(EmitOut { + meta, + nodes: w.tables.nodes, + edges: w.tables.edges, + refs: w.tables.refs, + arena: w.arena.into_vec(), + }) +} + +impl<'t> Walker<'t> { + fn text(&self, node: Node) -> &'t str { + &self.src[node.byte_range()] + } + fn line_of(&self, node: Node) -> u32 { + node.start_position().row as u32 + 1 + } + fn col_of(&self, node: Node) -> u32 { + util::col16(self.src, &self.line_starts, node.start_position().row, node.start_byte()) + } + fn end_col_of(&self, node: Node) -> u32 { + util::col16(self.src, &self.line_starts, node.end_position().row, node.end_byte()) + } + fn top_row(&self) -> u32 { + self.stack.last().map(|s| s.row).unwrap_or(0) + } + fn inside_class_like(&self) -> bool { + self.stack + .last() + .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module")) + .unwrap_or(false) + } + + fn push_ref_at(&mut self, from_row: u32, name: &str, kind: &str, node: Node) { + let name_ref = self.arena.put(name); + self.tables.push_ref(&RefRow { + from_idx: from_row, + kind: edge_kind_index(kind).unwrap(), + line: self.line_of(node), + column: self.col_of(node), + reference_name: name_ref, + candidates: NONE_STR, + from_id_str: NONE_STR, + }); + // Dart import names are URIs (`package:x/y.dart`) — they match neither + // SIMPLE_NAME nor QUALIFIED_IMPORT, so importedNames stays empty in + // practice; ported for fidelity. + if kind == "imports" { + if util::simple_name().is_match(name) { + self.imported_names.insert(name.to_string()); + } else if let Some(c) = util::qualified_import().captures(name) { + self.imported_names.insert(c[1].to_string()); + } + } + } + + // --- createNode (tree-sitter.ts:1308) --------------------------------- + + fn create_node(&mut self, kind: &'static str, name: &str, node: Node<'t>, extra: Extra) -> Option { + if name.is_empty() { + return None; + } + let start_line = self.line_of(node); + let id = ids::node_id(self.file_path, kind, name, start_line); + + let qualified = { + let mut parts: Vec<&str> = Vec::new(); + for s in &self.stack { + if s.kind != "file" { + parts.push(&s.name); + } + } + let mut qn = parts.join("::"); + if !qn.is_empty() { + qn.push_str("::"); + } + qn.push_str(name); + qn + }; + + // endLine extension (:1322-1334) — LIVE for dart: a function/method + // node's endLine extends to its sibling function_body's end. + let mut end_line = node.end_position().row as u32 + 1; + if let Some(ext) = extra.end_line_override { + if ext > end_line { + end_line = ext; + } + } + + let name_ref = self.arena.put(name); + let qn_ref = self.arena.put(&qualified); + let id_ref = self.arena.put(&id); + let doc_ref = opt_str(&mut self.arena, extra.docstring.as_deref()); + let sig_ref = opt_str(&mut self.arena, extra.signature.as_deref()); + let ret_ref = opt_str(&mut self.arena, extra.return_type.as_deref()); + let mut flags = BoolFlags::default(); + if let Some(v) = extra.is_async { + flags.set(FLAG_IS_ASYNC, v); + } + if let Some(v) = extra.is_static { + flags.set(FLAG_IS_STATIC, v); + } + let row = self.tables.push_node(&NodeRow { + kind: node_kind_index(kind).unwrap(), + visibility: extra.visibility, + flags, + start_line, + end_line, + start_column: self.col_of(node), + end_column: self.end_col_of(node), + name: name_ref, + qualified_name: qn_ref, + id: id_ref, + docstring: doc_ref, + signature: sig_ref, + decorators: NONE_STR, + type_parameters: NONE_STR, + return_type: ret_ref, + extra_json: NONE_STR, + }); + self.node_ids.push(id.clone()); + if kind == "function" || kind == "method" { + self.defined_fn_names.insert(name.to_string()); + } + + let parent_row = self.top_row(); + self.tables.push_edge(&EdgeRow { + source_idx: parent_row, + target_idx: row, + kind: edge_kind_index("contains").unwrap(), + provenance: 0, + line: NONE, + column: NONE, + metadata_json: NONE_STR, + source_id_str: NONE_STR, + target_id_str: NONE_STR, + }); + + // captureValueRefScope (:735-767). Dart mints only `constant` targets. + if (kind == "constant" || kind == "variable") + && util::utf16_len(name) >= 3 + && util::has_upper_or_underscore().is_match(name) + { + let parent_ok = self + .stack + .last() + .map(|s| matches!(s.kind, "file" | "class" | "module" | "struct" | "enum")) + .unwrap_or(false); + if parent_ok { + self.fs_values.insert(name.to_string(), row); + *self.fs_value_counts.entry(name.to_string()).or_insert(0) += 1; + } + } + if matches!(kind, "function" | "method" | "constant" | "variable") { + self.value_scopes.push(ValueScope { row, node, name: name.to_string() }); + } + + Some(row) + } + + // --- languages/dart.ts helper transcriptions -------------------------- + + /// dartInnerSignature (dart.ts:9-17). + fn inner_signature(&self, node: Node<'t>) -> Node<'t> { + if node.kind() == "method_signature" { + let mut cursor = node.walk(); + let inner = node.named_children(&mut cursor).find(|c| { + matches!(c.kind(), "function_signature" | "getter_signature" | "setter_signature") + }); + if let Some(inner) = inner { + return inner; + } + } + node + } + + /// dartConstructorSignature (dart.ts:25-35). + fn constructor_signature(&self, node: Node<'t>) -> Option> { + if matches!(node.kind(), "factory_constructor_signature" | "constructor_signature") { + return Some(node); + } + if node.kind() == "method_signature" { + let mut cursor = node.walk(); + return node.named_children(&mut cursor).find(|c| { + matches!(c.kind(), "factory_constructor_signature" | "constructor_signature") + }); + } + None + } + + /// dartEnclosingTypeName (dart.ts:38-50). + fn enclosing_type_name(&self, node: Node<'t>) -> Option<&'t str> { + let mut p = node.parent(); + while let Some(parent) = p { + if matches!( + parent.kind(), + "class_definition" | "mixin_declaration" | "extension_declaration" | "enum_declaration" + ) { + return parent.child_by_field_name("name").map(|n| self.text(n)); + } + p = parent.parent(); + } + None + } + + /// dartCtorInfo (dart.ts:61-70). + fn ctor_info(&self, node: Node<'t>) -> Option<(String, String)> { + let ctor = self.constructor_signature(node)?; + let mut cursor = ctor.walk(); + let ids: Vec> = ctor + .named_children(&mut cursor) + .filter(|c| c.kind() == "identifier") + .collect(); + let class_name = self.enclosing_type_name(node)?; + let first = ids.first()?; + if self.text(*first) != class_name { + return None; // misparsed method, not a ctor + } + let ctor_name = ids.get(1).map(|n| self.text(*n)).unwrap_or(class_name); + Some((class_name.to_string(), ctor_name.to_string())) + } + + /// extractDartReturnType (dart.ts:80-92). + fn return_type_of(&self, node: Node<'t>) -> Option { + if let Some((class_name, _)) = self.ctor_info(node) { + return Some(class_name); + } + let sig = self.inner_signature(node); + let mut cursor = sig.walk(); + let ret = sig + .named_children(&mut cursor) + .find(|c| c.kind() == "type_identifier")?; + let text = angle_args_re().replace_all(self.text(ret), ""); + let text = text.trim(); + let last = text.split('.').next_back()?; + if last.is_empty() || !simple_type_name_re().is_match(last) { + return None; + } + Some(last.to_string()) + } + + /// isMisparsedFunction (dart.ts:177-188) — skip the UNNAMED constructor. + fn is_unnamed_ctor(&self, node: Node<'t>) -> bool { + match self.ctor_info(node) { + Some((class_name, ctor_name)) => ctor_name == class_name, + None => false, + } + } + + /// getSignature (dart.ts:189-208). + fn signature_of(&self, node: Node<'t>) -> Option { + let sig = self.inner_signature(node); + let mut c1 = sig.walk(); + let params = sig + .named_children(&mut c1) + .find(|c| c.kind() == "formal_parameter_list"); + let mut c2 = sig.walk(); + let ret = sig + .named_children(&mut c2) + .find(|c| matches!(c.kind(), "type_identifier" | "void_type")); + if params.is_none() && ret.is_none() { + return None; + } + let mut result = String::new(); + if let Some(r) = ret { + result.push_str(self.text(r)); + result.push(' '); + } + if let Some(p) = params { + result.push_str(self.text(p)); + } + let trimmed = result.trim(); + if trimmed.is_empty() { + None + } else { + Some(trimmed.to_string()) + } + } + + /// getVisibility (dart.ts:209-222) — `_` prefix = private; every + /// constructor is public (the unwrap misses ctor signatures / the name + /// FIELD is the class identifier). + fn visibility_of(&self, node: Node<'t>) -> u8 { + let name_node = if node.kind() == "method_signature" { + let mut cursor = node.walk(); + let inner = node.named_children(&mut cursor).find(|c| { + matches!(c.kind(), "function_signature" | "getter_signature" | "setter_signature") + }); + inner.and_then(|i| { + let mut ic = i.walk(); + let found = i.named_children(&mut ic).find(|c| c.kind() == "identifier"); + found + }) + } else { + node.child_by_field_name("name") + }; + match name_node { + Some(n) if self.text(n).starts_with('_') => 2, + _ => 1, + } + } + + /// isAsync (dart.ts:223-233) — the `async` anon child of the SIBLING + /// function_body; `async*`/`sync*` are different token types → false. + fn is_async_of(&self, node: Node<'t>) -> bool { + if let Some(next) = node.next_named_sibling() { + if next.kind() == "function_body" { + for i in 0..next.child_count() { + if let Some(c) = next.child(i) { + if c.kind() == "async" { + return true; + } + } + } + } + } + false + } + + /// isStatic (dart.ts:234-243). + fn is_static_of(&self, node: Node<'t>) -> bool { + if node.kind() == "method_signature" { + for i in 0..node.child_count() { + if let Some(c) = node.child(i) { + if c.kind() == "static" { + return true; + } + } + } + } + false + } + + /// resolveBody (dart.ts:158-171). + fn resolve_body(&self, node: Node<'t>) -> Option> { + if matches!(node.kind(), "function_signature" | "method_signature") { + let next = node.next_named_sibling()?; + if next.kind() == "function_body" { + return Some(next); + } + return None; + } + if let Some(standard) = node.child_by_field_name("body") { + return Some(standard); + } + let mut cursor = node.walk(); + let found = node + .named_children(&mut cursor) + .find(|c| matches!(c.kind(), "class_body" | "extension_body")); + found + } + + /// extractName (tree-sitter.ts:90-192) — resolveName (ctor names) → + /// name field → the method_signature inner unwrap → identifier-ish + /// child → `` (operators land here). + fn extract_name(&self, node: Node<'t>) -> String { + // resolveName hook (dart.ts:244-260): named ctor/factory → ctor name. + if let Some((class_name, ctor_name)) = self.ctor_info(node) { + if ctor_name != class_name { + return ctor_name; + } + } + if let Some(name_node) = node.child_by_field_name("name") { + return self.text(name_node).to_string(); + } + if node.kind() == "method_signature" { + let mut cursor = node.walk(); + let inner = node.named_children(&mut cursor).find(|c| { + matches!( + c.kind(), + "function_signature" | "getter_signature" | "setter_signature" + | "constructor_signature" | "factory_constructor_signature" + ) + }); + if let Some(inner) = inner { + let mut ic = inner.walk(); + let id = inner.named_children(&mut ic).find(|c| c.kind() == "identifier"); + if let Some(id) = id { + return self.text(id).to_string(); + } + } + } + let mut cursor = node.walk(); + for c in node.named_children(&mut cursor) { + if matches!(c.kind(), "identifier" | "type_identifier" | "simple_identifier" | "constant") { + return self.text(c).to_string(); + } + } + "".to_string() + } + + // --- the main walk (visitNode, tree-sitter.ts:936-1303) --------------- + + fn visit(&mut self, node: Node<'t>) { + // The visitNode hook (dart.ts:144-157) — the constants branch. + if node.kind() == "static_final_declaration" { + let mut cursor = node.walk(); + let name_node = node.named_children(&mut cursor).find(|c| c.kind() == "identifier"); + if let Some(name_node) = name_node { + // signature = first value sibling's text, sliced to 100 + // UTF-16 units (a flattened chain captures just its head). + let signature = name_node.next_named_sibling().map(|v| { + let (sliced, _) = util::slice_utf16(self.text(v), 100); + if util::utf16_len(&sliced) >= 100 { + format!("= {sliced}...") + } else { + format!("= {sliced}") + } + }); + let name = self.text(name_node).to_string(); + self.create_node("constant", &name, node, Extra { signature, ..Default::default() }); + } + self.scan_fn_ref_subtree(node, 0); + return; + } + + // maybeCaptureFnRefs (:990) — the double-walk fn-ref twin source. + self.maybe_capture_fn_refs(node); + + match node.kind() { + "function_signature" => { + // functionTypes row — method_signature does NOT include it → + // always extractFunction, even inside a class (abstract + // members become kind `function` contained by the class). + self.extract_function(node); + return; + } + "class_definition" | "mixin_declaration" | "extension_declaration" => { + self.extract_class(node); + return; + } + "method_signature" | "constructor_signature" => { + self.extract_method(node); + return; + } + "enum_declaration" => { + self.extract_enum(node); + return; + } + "type_alias" => { + let skip = self.extract_type_alias(node); + if skip { + return; + } + } + "import_or_export" => { + self.extract_import(node); + return; + } + "new_expression" => { + // INSTANTIATION_KINDS row — from the FILE/CLASS on the + // sibling revisit (the double-walk's pass 2a). + self.extract_instantiation(node); + } + _ => {} + } + + let mut cursor = node.walk(); + let children: Vec> = node.named_children(&mut cursor).collect(); + for child in children { + self.visit(child); + } + } + + // --- extractFunction / extractMethod (:1517 / :1737) ------------------ + + fn extract_function(&mut self, node: Node<'t>) { + // No receiver hook. Name first (resolveName inside extract_name). + let name = self.extract_name(node); + if name == "" { + // :1549 — body-only walk (nothing pushed). Dart signatures always + // name; preserved for fidelity. + if let Some(body) = self.resolve_body(node) { + self.visit_body(body); + } + return; + } + // isMisparsedFunction: the unnamed constructor is skipped — node + // suppressed, body still walked (attributed to the current stack top). + if self.is_unnamed_ctor(node) { + if let Some(body) = self.resolve_body(node) { + self.visit_body(body); + } + return; + } + let docstring = preceding_docstring(node, self.src); + let signature = self.signature_of(node); + let visibility = self.visibility_of(node); + let is_async = self.is_async_of(node); + let is_static = self.is_static_of(node); + let return_type = self.return_type_of(node); + let body = self.resolve_body(node); + let end_line_override = body.map(|b| b.end_position().row as u32 + 1); + let row = self.create_node( + "function", + &name, + node, + Extra { + docstring, + signature, + visibility, + is_async: Some(is_async), + is_static: Some(is_static), + return_type, + end_line_override, + }, + ); + let Some(row) = row else { return }; + self.extract_type_annotations(node, row); + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "function", name }); + if let Some(body) = body { + self.visit_body(body); + } + self.stack.pop(); + } + + fn extract_method(&mut self, node: Node<'t>) { + // Gate (:1747): not inside class-like (no methodsAreTopLevel, no + // receiver, parent never object/object_expression) → extractFunction. + if !self.inside_class_like() { + self.extract_function(node); + return; + } + let name = self.extract_name(node); + // isMisparsedFunction — the unnamed ctor: body-only walk. + if self.is_unnamed_ctor(node) { + if let Some(body) = self.resolve_body(node) { + self.visit_body(body); + } + return; + } + let docstring = preceding_docstring(node, self.src); + let signature = self.signature_of(node); + let visibility = self.visibility_of(node); + let is_async = self.is_async_of(node); + let is_static = self.is_static_of(node); + let return_type = self.return_type_of(node); + let body = self.resolve_body(node); + let end_line_override = body.map(|b| b.end_position().row as u32 + 1); + // Operators mint method "" — extractMethod has NO skip. + let row = self.create_node( + "method", + &name, + node, + Extra { + docstring, + signature, + visibility, + is_async: Some(is_async), + is_static: Some(is_static), + return_type, + end_line_override, + }, + ); + let Some(row) = row else { return }; + self.extract_type_annotations(node, row); + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "method", name }); + if let Some(body) = body { + self.visit_body(body); + } + self.stack.pop(); + } + + // --- extractClass (:1679) — classes, mixins, extensions --------------- + + fn extract_class(&mut self, node: Node<'t>) { + let resolved_body = self.resolve_body(node); + // No skipBodilessClass. Anonymous `extension on String` → the name + // fallback finds the ON type's type_identifier — a class named after + // the extended type (preserved). + let name = self.extract_name(node); + let docstring = preceding_docstring(node, self.src); + let visibility = self.visibility_of(node); + let row = self.create_node( + "class", + &name, + node, + Extra { docstring, visibility, ..Default::default() }, + ); + let Some(row) = row else { return }; + self.extract_inheritance(node, row); + // extractCsharpPrimaryCtorParamRefs — csharp-gated no-op. + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "class", name }); + let body = resolved_body.unwrap_or(node); + let mut cursor = body.walk(); + let children: Vec> = body.named_children(&mut cursor).collect(); + for child in children { + self.visit(child); + } + self.stack.pop(); + } + + // --- extractEnum (:1914) ---------------------------------------------- + + fn extract_enum(&mut self, node: Node<'t>) { + let body = match self.resolve_body(node) { + Some(b) => b, + None => return, + }; + let name = self.extract_name(node); + let docstring = preceding_docstring(node, self.src); + let visibility = self.visibility_of(node); + let row = self.create_node( + "enum", + &name, + node, + Extra { docstring, visibility, ..Default::default() }, + ); + let Some(row) = row else { return }; + // Enum `with` mixins are a DIRECT child (no superclass wrapper) → + // no clause matches; `interfaces` DOES → implements only. + self.extract_inheritance(node, row); + // No extractDecoratorsFor on the enum path. + self.stack.push(Scope { row, kind: "enum", name }); + let mut cursor = body.walk(); + let children: Vec> = body.named_children(&mut cursor).collect(); + for child in children { + if child.kind() == "enum_constant" { + self.extract_enum_members(child); + } else { + self.visit(child); + } + } + self.stack.pop(); + } + + /// extractEnumMembers (:1958) — one enum_member per constant, positioned + /// at the enum_constant node; ctor arguments never walked. + fn extract_enum_members(&mut self, node: Node<'t>) { + if let Some(name_node) = node.child_by_field_name("name") { + let name = self.text(name_node).to_string(); + self.create_node("enum_member", &name, node, Extra::default()); + } + } + + // --- extractTypeAlias (:2890, plain path) ----------------------------- + + fn extract_type_alias(&mut self, node: Node<'t>) -> bool { + let name = self.extract_name(node); + if name == "" { + return false; + } + let docstring = preceding_docstring(node, self.src); + // `value` field is null (type_alias has no fields) → no refs from + // the aliased type; returns false → children re-visited. + self.create_node("type_alias", &name, node, Extra { docstring, ..Default::default() }); + false + } + + // --- extractImport (:3170; hook dart.ts:261-304) ---------------------- + + fn extract_import(&mut self, node: Node<'t>) { + let find_child = |parent: Node<'t>, kind: &str| -> Option> { + let mut cursor = parent.walk(); + let found = parent.named_children(&mut cursor).find(|c| c.kind() == kind); + found + }; + let uri_of = |spec: Node<'t>| -> Option> { + let configurable = find_child(spec, "configurable_uri")?; + let uri = find_child(configurable, "uri")?; + find_child(uri, "string_literal") + }; + let mut module: Option = None; + if let Some(li) = find_child(node, "library_import") { + if let Some(spec) = find_child(li, "import_specification") { + if let Some(sl) = uri_of(spec) { + module = Some(self.text(sl).replace(['\'', '"'], "")); + } + } + } + if module.is_none() { + if let Some(le) = find_child(node, "library_export") { + if let Some(sl) = uri_of(le) { + module = Some(self.text(sl).replace(['\'', '"'], "")); + } + } + } + // Deferred imports (bare `uri`, no configurable_uri) → hook null → + // nothing at all (invisible). + let Some(module) = module.filter(|m| !m.is_empty()) else { return }; + let signature = self.text(node).trim().to_string(); + let created = self.create_node( + "import", + &module, + node, + Extra { signature: Some(signature), ..Default::default() }, + ); + if created.is_some() && !self.stack.is_empty() { + let parent_row = self.top_row(); + self.push_ref_at(parent_row, &module, "imports", node); + } + } + + // --- extractInstantiation (:4610, generic tail) ----------------------- + + fn extract_instantiation(&mut self, node: Node<'t>) { + if self.stack.is_empty() { + return; + } + let from_row = self.top_row(); + let ctor = node + .child_by_field_name("constructor") + .or_else(|| node.child_by_field_name("type")) + .or_else(|| node.child_by_field_name("name")) + .or_else(|| node.named_child(0)); + let Some(ctor) = ctor else { return }; + let mut class_name = self.text(ctor).to_string(); + if let Some(lt) = class_name.find('<') { + if lt > 0 { + class_name.truncate(lt); + } + } + let last_dot = class_name.rfind('.').map(|i| i as i64).unwrap_or(-1); + let last_colons = class_name.rfind("::").map(|i| (i + 1) as i64).unwrap_or(-1); + let last = last_dot.max(last_colons); + if last >= 0 { + class_name = class_name[(last as usize + 1)..].to_string(); + class_name = class_name.trim_start_matches([':', '.']).to_string(); + } + let class_name = class_name.trim().to_string(); + if class_name.is_empty() { + return; + } + self.push_ref_at(from_row, &class_name, "instantiates", node); + } + + // --- extractBareCall (dart.ts:305-379) -------------------------------- + + fn bare_call_name(&self, node: Node<'t>) -> Option { + if node.kind() == "selector" { + let mut cursor = node.walk(); + let has_arg_part = node.named_children(&mut cursor).any(|c| c.kind() == "argument_part"); + if !has_arg_part { + return None; + } + let prev = node.prev_named_sibling()?; + if prev.kind() == "identifier" { + return Some(self.text(prev).to_string()); + } + if prev.kind() == "selector" { + let mut pc = prev.walk(); + let accessor = prev.named_children(&mut pc).find(|c| { + matches!( + c.kind(), + "unconditional_assignable_selector" | "conditional_assignable_selector" + ) + }); + if let Some(accessor) = accessor { + let mut ac = accessor.walk(); + let method_id = accessor.named_children(&mut ac).find(|c| c.kind() == "identifier"); + if let Some(method_id) = method_id { + let accessor_prev = prev.prev_named_sibling(); + if let Some(ap) = accessor_prev { + if ap.kind() == "identifier" { + return Some(format!("{}.{}", self.text(ap), self.text(method_id))); + } + // Chained static-factory: the receiver is itself + // a call — re-encode `().` when + // the chain starts capitalized (#750). + if ap.kind() == "selector" { + let mut apc = ap.walk(); + if ap.named_children(&mut apc).any(|c| c.kind() == "argument_part") { + if let Some(inner) = self.callee_of_arg_part(ap) { + if starts_upper_re().is_match(&inner) { + return Some(format!("{}().{}", inner, self.text(method_id))); + } + } + } + } + } + return Some(self.text(method_id).to_string()); + } + } + } + // super.method() / this.method(): prev is a bare accessor. + if matches!( + prev.kind(), + "unconditional_assignable_selector" | "conditional_assignable_selector" + ) { + let mut pc = prev.walk(); + let id = prev.named_children(&mut pc).find(|c| c.kind() == "identifier"); + if let Some(id) = id { + return Some(self.text(id).to_string()); + } + } + return None; + } + + // new_expression arm — DEAD in practice (the INSTANTIATION branch + // fires first in the body walker); ported for fidelity. + if node.kind() == "new_expression" { + let mut cursor = node.walk(); + let found = node + .named_children(&mut cursor) + .find(|c| c.kind() == "type_identifier") + .map(|t| self.text(t).to_string()); + return found; + } + + // const EdgeInsets.all(8.0) — const constructor call. + if node.kind() == "const_object_expression" { + let mut c1 = node.walk(); + let type_id = node.named_children(&mut c1).find(|c| c.kind() == "type_identifier"); + let mut c2 = node.walk(); + let name_id = node.named_children(&mut c2).find(|c| c.kind() == "identifier"); + return match (type_id, name_id) { + (Some(t), Some(n)) => Some(format!("{}.{}", self.text(t), self.text(n))), + (Some(t), None) => Some(self.text(t).to_string()), + _ => None, + }; + } + + None + } + + /// dartCalleeOfArgPart (dart.ts:100-116). + fn callee_of_arg_part(&self, arg_part: Node<'t>) -> Option { + let prev = arg_part.prev_named_sibling()?; + if prev.kind() == "identifier" { + return Some(self.text(prev).to_string()); + } + if prev.kind() == "selector" { + let mut pc = prev.walk(); + let accessor = prev.named_children(&mut pc).find(|c| { + matches!( + c.kind(), + "unconditional_assignable_selector" | "conditional_assignable_selector" + ) + }); + let method_id = accessor.and_then(|a| { + let mut ac = a.walk(); + let found = a.named_children(&mut ac).find(|c| c.kind() == "identifier"); + found + }); + if let Some(method_id) = method_id { + let accessor_prev = prev.prev_named_sibling(); + if let Some(ap) = accessor_prev { + if ap.kind() == "identifier" { + return Some(format!("{}.{}", self.text(ap), self.text(method_id))); + } + } + return Some(self.text(method_id).to_string()); + } + } + None + } + + // --- extractStaticMemberRef — the dart branch (:4759-4767) ------------ + + fn extract_static_member_ref(&mut self, node: Node<'t>) { + if self.stack.is_empty() { + return; + } + let owner_row = self.top_row(); + if node.kind() != "selector" { + return; + } + let mut cursor = node.walk(); + if node.named_children(&mut cursor).any(|c| c.kind() == "argument_part") { + return; + } + let Some(prev) = node.prev_named_sibling() else { return }; + if prev.kind() == "identifier" && cap_ident_re().is_match(self.text(prev)) { + let name = self.text(prev).to_string(); + // NO callee-of-call skip — `ConfigT.load()` double-emits + // (references + calls). Position = the IDENTIFIER (receiver). + self.push_ref_at(owner_row, &name, "references", prev); + } + } + + // --- extractDecoratorsFor (:4897-5024) — the sibling scan ------------- + + fn extract_decorators_for(&mut self, decl: Node<'t>, decorated_row: u32) { + // Scan 1: direct children (+ modifiers descent) — inert for dart + // (annotations are preceding siblings), ported for fidelity. + let mut cursor = decl.walk(); + let kids: Vec> = decl.named_children(&mut cursor).collect(); + for child in kids { + self.consider_decorator(child, decorated_row); + if child.kind() == "modifiers" { + let mut mc = child.walk(); + let inner: Vec> = child.named_children(&mut mc).collect(); + for m in inner { + self.consider_decorator(m, decorated_row); + } + } + } + // Scan 2: preceding siblings, backward, stop at the first + // non-annotation — stacked annotations emit in REVERSE source order. + if let Some(parent) = decl.parent() { + let decl_start = decl.start_byte(); + let mut decl_idx: Option = None; + for i in 0..parent.named_child_count() { + if let Some(sib) = parent.named_child(i) { + if sib.start_byte() == decl_start { + decl_idx = Some(i); + break; + } + } + } + if let Some(di) = decl_idx { + for j in (0..di).rev() { + let Some(sib) = parent.named_child(j) else { continue }; + if !matches!(sib.kind(), "decorator" | "annotation" | "marker_annotation") { + break; + } + self.consider_decorator(sib, decorated_row); + } + } + } + } + + fn consider_decorator(&mut self, n: Node<'t>, decorated_row: u32) { + if !matches!(n.kind(), "decorator" | "annotation" | "marker_annotation" | "attribute") { + return; + } + let mut target: Option> = None; + let mut cursor = n.walk(); + let kids: Vec> = n.named_children(&mut cursor).collect(); + for child in kids { + if child.kind() == "call_expression" { + let fnn = child.child_by_field_name("function").or_else(|| child.named_child(0)); + if let Some(f) = fnn { + target = Some(f); + } + if target.is_some() { + break; + } + } + if matches!( + child.kind(), + "identifier" | "member_expression" | "scoped_identifier" | "navigation_expression" + | "user_type" | "type_identifier" + ) { + target = Some(child); + break; + } + } + let Some(target) = target else { return }; + let mut name = self.text(target).to_string(); + if let Some(lt) = name.find('<') { + if lt > 0 { + name.truncate(lt); + } + } + let last_dot = name.rfind('.').map(|i| i as i64).unwrap_or(-1); + let last_colons = name.rfind("::").map(|i| (i + 1) as i64).unwrap_or(-1); + let last = last_dot.max(last_colons); + if last >= 0 { + name = name[(last as usize + 1)..].to_string(); + name = name.trim_start_matches([':', '.']).to_string(); + } + let name = name.trim().to_string(); + if name.is_empty() { + return; + } + self.push_ref_at(decorated_row, &name, "decorates", n); + } + + // --- extractInheritance — the dart rows (:5368-5393, :5437-5459) ------ + + fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) { + let mut cursor = node.walk(); + let kids: Vec> = node.named_children(&mut cursor).collect(); + for child in kids { + if child.kind() == "superclass" { + // extends type + `with` mixins (implements) — dart branch. + let mut cc = child.walk(); + let targets: Vec> = child.named_children(&mut cc).collect(); + for t in targets { + if t.kind() == "mixins" { + let mut mc = t.walk(); + let mixins: Vec> = t.named_children(&mut mc).collect(); + for m in mixins { + if m.kind() == "type_identifier" { + let name = self.text(m).to_string(); + self.push_ref_at(class_row, &name, "implements", m); + } + } + } else if t.kind() == "type_identifier" { + let name = self.text(t).to_string(); + self.push_ref_at(class_row, &name, "extends", t); + } + } + } else if child.kind() == "interfaces" { + // implements — one per named child, FULL child text. + let mut cc = child.walk(); + let targets: Vec> = child.named_children(&mut cc).collect(); + for iface in targets { + let name = self.text(iface).to_string(); + self.push_ref_at(class_row, &name, "implements", iface); + } + } + } + } + + // --- extractTypeAnnotations — the dart path (:5819-5833) -------------- + + fn extract_type_annotations(&mut self, node: Node<'t>, row: u32) { + let sig = if node.kind() == "method_signature" { + let mut cursor = node.walk(); + let found = node.named_children(&mut cursor).find(|c| { + matches!( + c.kind(), + "function_signature" | "getter_signature" | "setter_signature" + | "constructor_signature" | "factory_constructor_signature" + ) + }); + found.unwrap_or(node) // operators fall back to the wrapper itself + } else { + node + }; + self.type_refs_from_subtree(sig, row); + } + + fn type_refs_from_subtree(&mut self, node: Node<'t>, from_row: u32) { + if node.kind() == "type_identifier" { + let name = self.text(node); + if !name.is_empty() && !is_builtin_type(name) { + let name = name.to_string(); + self.push_ref_at(from_row, &name, "references", node); + } + return; + } + let mut cursor = node.walk(); + let kids: Vec> = node.named_children(&mut cursor).collect(); + for c in kids { + self.type_refs_from_subtree(c, from_row); + } + } + + // --- visitFunctionBody (:5129-5286) — dart rows ----------------------- + + fn visit_body(&mut self, node: Node<'t>) { + self.maybe_capture_fn_refs(node); + + let kind = node.kind(); + if kind == "new_expression" { + // INSTANTIATION branch fires first — extractBareCall's + // new_expression arm is dead. Children still recursed. + self.extract_instantiation(node); + } else if let Some(callee) = self.bare_call_name(node) { + // extractBareCall (:5159-5173) — ref at the MATCHED node. + if !self.stack.is_empty() { + let caller_row = self.top_row(); + self.push_ref_at(caller_row, &callee, "calls", node); + } + } + + self.extract_static_member_ref(node); + + if kind == "function_signature" { + // Nested named functions (:5245) — extractFunction walks the + // nested body itself; the enclosing walker ALSO revisits the + // sibling function_body (double-walk pass 2b) via recursion. + self.extract_function(node); + return; + } + + let mut cursor = node.walk(); + let children: Vec> = node.named_children(&mut cursor).collect(); + for child in children { + self.visit_body(child); + } + } + + // --- function-as-value capture (#756) — DART_SPEC --------------------- + + fn maybe_capture_fn_refs(&mut self, node: Node<'t>) { + let (mode, field): (&str, &str) = match node.kind() { + "arguments" => ("args", ""), + "assignment_expression" => ("rhs", "right"), + "pair" => ("value", "value"), + "list_literal" => ("list", ""), + "static_final_declaration" => ("varinit", ""), + _ => return, + }; + if self.stack.is_empty() { + return; + } + let from = self.top_row(); + + let mut values: Vec> = Vec::new(); + match mode { + "args" | "list" => { + let mut cursor = node.walk(); + for c in node.named_children(&mut cursor) { + values.push(c); + } + } + "rhs" => { + if let Some(rhs) = node.child_by_field_name(field) { + let lhs = node + .child_by_field_name("left") + .or_else(|| node.child_by_field_name("lhs")) + .or_else(|| node.child_by_field_name("target")) + .or_else(|| { + if node.named_child_count() >= 2 { + node.named_child(0) + } else { + None + } + }); + let lhs_text = lhs.map(|l| self.text(l)).unwrap_or(""); + let lhs_last = util::lhs_last_name() + .captures(lhs_text) + .and_then(|c| c.get(1)) + .map(|m| m.as_str()); + if !(lhs_last.is_some() && lhs_last == Some(self.text(rhs).trim())) { + values.push(rhs); + } + } + } + "value" => { + let v = node.child_by_field_name(field).or_else(|| { + let count = node.named_child_count(); + if count > 0 { node.named_child(count - 1) } else { None } + }); + if let Some(v) = v { + values.push(v); + } + } + _ => { + // varinit, NO field (function-ref.ts:471-487): the last named + // child, requiring ≥2 named children; the name-field guard is + // inert (static_final_declaration has no name/pattern field). + let count = node.named_child_count(); + if count >= 2 { + if let Some(v) = node.named_child(count - 1) { + values.push(v); + } + } + } + } + + for v in values { + self.normalize_fn_ref_value(v, from, 0); + } + } + + /// normalizeValue with DART_SPEC's one layer (`argument` → fan out). + /// Named arguments are NOT captured (named_argument is not a layer). + fn normalize_fn_ref_value(&mut self, v: Node<'t>, from: u32, depth: u32) { + if depth > 4 { + return; + } + match v.kind() { + "identifier" => { + let name = self.text(v).to_string(); + if name.is_empty() || is_stoplisted(&name) { + return; + } + let p = v.start_position(); + self.fn_ref_cands.push(Cand { + from, + name, + line: p.row as u32 + 1, + column_byte: v.start_byte(), + row: p.row, + }); + } + "argument" => { + let mut cursor = v.walk(); + let kids: Vec> = v.named_children(&mut cursor).collect(); + for c in kids { + self.normalize_fn_ref_value(c, from, depth + 1); + } + } + _ => {} + } + } + + fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32) { + if depth > 12 { + return; + } + // Halt list: functionTypes (function_signature) + the lambda kinds — + // function_expression IS dart's lambda, so constant-initializer + // lambdas don't leak candidates. + if depth > 0 + && matches!( + node.kind(), + "function_signature" | "arrow_function" | "function_expression" + | "lambda_literal" | "lambda_expression" + ) + { + return; + } + self.maybe_capture_fn_refs(node); + let mut cursor = node.walk(); + let children: Vec> = node.named_children(&mut cursor).collect(); + for c in children { + self.scan_fn_ref_subtree(c, depth + 1); + } + } + + fn flush_fn_ref_candidates(&mut self) { + let cands = std::mem::take(&mut self.fn_ref_cands); + if cands.is_empty() || util::is_generated_file(self.file_path) { + return; + } + let mut seen: HashSet<(String, String)> = HashSet::new(); + for c in cands { + if !c.name.starts_with("this.") + && !c.name.contains("::") + && !self.defined_fn_names.contains(&c.name) + && !self.imported_names.contains(&c.name) + { + continue; + } + if !seen.insert((self.node_ids[c.from as usize].clone(), c.name.clone())) { + continue; + } + let column = util::col16(self.src, &self.line_starts, c.row, c.column_byte); + let name_ref = self.arena.put(&c.name); + self.tables.push_ref(&RefRow { + from_idx: c.from, + kind: FUNCTION_REF_CODE, + line: c.line, + column, + reference_name: name_ref, + candidates: NONE_STR, + from_id_str: NONE_STR, + }); + } + } + + // --- value-reference edges (:398-931) --------------------------------- + + fn flush_value_refs(&mut self, root: Node<'t>) { + let scopes = std::mem::take(&mut self.value_scopes); + let mut targets = std::mem::take(&mut self.fs_values); + let counts = std::mem::take(&mut self.fs_value_counts); + if std::env::var("CODEGRAPH_VALUE_REFS").as_deref() == Ok("0") { + return; + } + if targets.is_empty() || scopes.is_empty() || util::is_generated_file(self.file_path) { + return; + } + + // Shadow prune — the dart declarator shapes (:844-850): each bumps + // its first identifier-typed named child. Uninitialized locals bump; + // assignment_expression is NOT a prune case. + let mut decl_counts: HashMap<&str, u32> = HashMap::new(); + let mut dstack: Vec = vec![root]; + let mut dvisited = 0usize; + while let Some(n) = dstack.pop() { + if dvisited >= MAX_VALUE_REF_NODES { + break; + } + dvisited += 1; + if matches!( + n.kind(), + "static_final_declaration" | "initialized_identifier" | "initialized_variable_definition" + ) { + let mut cursor = n.walk(); + let id = n.named_children(&mut cursor).find(|c| c.kind() == "identifier"); + if let Some(id) = id { + let nm = self.text(id); + if targets.contains_key(nm) { + *decl_counts.entry(nm).or_insert(0) += 1; + } + } + } + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + dstack.push(c); + } + } + } + let shadowed: Vec = decl_counts + .iter() + .filter(|(nm, c)| **c > counts.get(**nm).copied().unwrap_or(1)) + .map(|(nm, _)| nm.to_string()) + .collect(); + for nm in shadowed { + targets.remove(&nm); + } + if targets.is_empty() { + return; + } + + let refs_kind = edge_kind_index("references").unwrap(); + for scope in &scopes { + let mut seen: HashSet<&str> = HashSet::new(); + let mut stack: Vec = vec![scope.node]; + // The Dart sibling-body pull (:883-892) is LIVE and load-bearing: + // reader scopes are SIGNATURE nodes; their reads live in the + // sibling function_body. + if let Some(sib) = scope.node.next_named_sibling() { + if matches!(sib.kind(), "function_body" | "block") { + stack.push(sib); + } + } + let mut visited = 0usize; + while let Some(n) = stack.pop() { + if visited >= MAX_VALUE_REF_NODES { + break; + } + visited += 1; + if matches!(n.kind(), "identifier" | "constant" | "name" | "simple_identifier") { + let ref_name = self.text(n); + if let Some(&target_row) = targets.get(ref_name) { + let target_id = self.node_ids[target_row as usize].as_str(); + if target_id != self.node_ids[scope.row as usize] + && ref_name != scope.name + && !seen.contains(&target_id) + { + seen.insert(target_id); + let meta = self.arena.put(r#"{"valueRef":true}"#); + self.tables.push_edge(&EdgeRow { + source_idx: scope.row, + target_idx: target_row, + kind: refs_kind, + provenance: 0, + line: NONE, + column: NONE, + metadata_json: meta, + source_id_str: NONE_STR, + target_id_str: NONE_STR, + }); + } + } + } + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + stack.push(c); + } + } + } + } + } +} + +fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef { + match s { + Some(s) => arena.put(s), + None => NONE_STR, + } +} diff --git a/codegraph-kernel/src/langs.rs b/codegraph-kernel/src/langs.rs index 39cb0d4..5e62984 100644 --- a/codegraph-kernel/src/langs.rs +++ b/codegraph-kernel/src/langs.rs @@ -28,12 +28,17 @@ extern "C" { extern "C" { fn tree_sitter_scala() -> *const (); } +// Vendored dart grammar (build.rs-compiled C — UserNobody14 d4d8f3e; the +// crates.io crate is a different-lineage fork; see grammars/dart). +extern "C" { + fn tree_sitter_dart() -> *const (); +} /// Languages this kernel binary can extract (reported by contractInfo; /// TS-side routing policy decides what actually routes). -pub const LANGUAGES: [&str; 19] = [ +pub const LANGUAGES: [&str; 20] = [ "typescript", "tsx", "javascript", "jsx", "java", "python", "go", "c", "cpp", "rust", - "csharp", "ruby", "php", "swift", "kotlin", "r", "lua", "luau", "scala", + "csharp", "ruby", "php", "swift", "kotlin", "r", "lua", "luau", "scala", "dart", ]; pub fn grammar_for(language: &str) -> Option { @@ -83,6 +88,11 @@ pub fn grammar_for(language: &str) -> Option { "scala" => { Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_scala) }.into()) } + // R7b batch 4: UserNobody14 d4d8f3e vendored C compiled in build.rs + // (same commit as the byte-copied tree-sitter-wasms 0.1.13 artifact). + "dart" => { + Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_dart) }.into()) + } _ => None, } } diff --git a/codegraph-kernel/src/lib.rs b/codegraph-kernel/src/lib.rs index 5ed2561..d600b0c 100644 --- a/codegraph-kernel/src/lib.rs +++ b/codegraph-kernel/src/lib.rs @@ -20,6 +20,7 @@ mod buffers; mod ccpp; mod cfnptr; mod csharp; +mod dart; mod docstring; mod ids; mod go; @@ -229,6 +230,7 @@ pub fn extract_file(file_path: String, content: String, language: String) -> Res "r" => rlang::extract(&file_path, &content).map_err(Error::from_reason)?, "lua" | "luau" => lua::extract(&file_path, &content, &language).map_err(Error::from_reason)?, "scala" => scala::extract(&file_path, &content).map_err(Error::from_reason)?, + "dart" => dart::extract(&file_path, &content).map_err(Error::from_reason)?, _ => tsjs::extract(&file_path, &content, &language).map_err(Error::from_reason)?, }; Ok(ExtractBuffers { diff --git a/docs/design/dart-kernel-port-checklist.md b/docs/design/dart-kernel-port-checklist.md new file mode 100644 index 0000000..d354281 --- /dev/null +++ b/docs/design/dart-kernel-port-checklist.md @@ -0,0 +1,1082 @@ +# Dart kernel port (R7b batch 4) — the bug-for-bug checklist + +**Status: SURVEY COMPLETE (2026-07-20), port not started.** Survey basis: every +TS-side branch a `.dart` file exercises, with file:line anchors as of +**`45a53eb`** (HEAD at survey time, clean main). Every extraction-behavior +claim below was **pinned against the real `dist/` extractor** (the +`extract-*.txt` ground-truth dumps in the session scratchpad `svy-dart/` — +§Probe artifacts), and every grammar-shape claim was **probed against the +production wasm** (tree-sitter-wasms 0.1.13's dart build) via full CST dumps — +not inferred from reading code. Field-presence claims come from +`fieldNameForChild` dumps corroborated by extractor behavior (the swift +lesson: dump labels alone lie — here every field claim is backed by an +extractor-output pin). Read WITH `docs/design/rust-kernel-migration-plan.md` +(§0a recipe, §2 boundary, §4 tracker, §5 gates) and the format precedents +(`kotlin-kernel-port-checklist.md` — the closest structural sibling: +visitNode-hook constants, vendored-grammar-C build; `swift-kernel-port-checklist.md` +— the shared-branch liveness style and high-deferral posture). + +**Blocking findings: none — but one mechanism is NOVEL and load-bearing, and +one number is big.** (1) **The sibling-body double-walk (§The double-walk) is +the center of gravity of this port.** Dart's grammar attaches every +function/method BODY as a *next sibling* of its signature node, and the TS +walkers consume the body TWICE — once via `resolveBody` (attributed to the +function/method) and once via the enclosing generic walk (attributed to the +file/class). The result is a deterministic pattern of duplicate nodes +(local functions minted twice under different parents with the SAME id), +duplicate `instantiates`/`calls` refs, and file/class-attributed +`function_ref` twins — all of which the walker must reproduce byte-for-byte, +in exactly the observed interleave. NO previously ported walker has this +surface. (2) **Both-arm parse-error incidence is 3.4–20.7% on the gate +repos** — flutter/flutter sits at 20.73% because the grammar (2025-10) cannot +parse *empty* object patterns (`TimerInitial() =>`, the dominant sealed-class +state-matching idiom) or the unnamed `library;` directive. Run parity sweeps +with **`--max-deferral 0.3`** (swift-style exemption). 0 phantom errors were +found anywhere (3 repos + a 46-snippet battery) — unlike kotlin — but the +defer rule stays trust-the-flag. (3) The "grammar bump" for dart is a +**byte-copy of the ALREADY-SHIPPING wasm** (unpinned-dep de-risking, not a +version change), so the bump gate is trivial — expect byte-identical +everything; the only real grammar gate is kernel-grammar-parity (vendored-C +build ↔ vendored wasm table identity). + +## Grammar prep (wasm byte-copy vendor + vendored-C kernel build) + +dart is NOT in `VENDORED_WASM_LANGS` (grammars.ts:291-333) — production +resolves `require.resolve('tree-sitter-wasms/out/tree-sitter-dart.wasm')` +(mapping `dart: 'tree-sitter-dart.wasm'` grammars.ts:36; `.dart` → dart at +grammars.ts:108, no content sniffing, no dialects). tree-sitter-wasms 0.1.13's +dart dependency is **UNPINNED `github:UserNobody14/tree-sitter-dart`**, built +at the 0.1.13 publish (2025-10-07) — a tree-sitter-wasms update would silently +change dart's grammar, which is exactly the hazard this vendor kills. + +- **Provenance (verified by the batch-4 grammar probe, re-verified here):** + UserNobody14/tree-sitter-dart **master@`d4d8f3e337d8be23be27ffc35a0aef972343cd54`** + (2025-10-04, "Fix `set` and `get` contextual keywords…" #89) — parser.c + tables positionally identical to the shipped wasm (ABI **15**, STATE_COUNT + 3640, SYMBOL_COUNT 524 + ALIAS_COUNT 1, TOKEN_COUNT 161, 22 fields, + EXTERNAL_TOKEN_COUNT 7). +- **Production wasm** sha256 + `7f5364e4256cf7e55efd01dd52421ef2663caa8061b82659b7e4bf61064545ec` + (984,666 bytes, `node_modules/tree-sitter-wasms/out/tree-sitter-dart.wasm`). + **Vendor plan: BYTE-COPY this file** to + `src/extraction/wasm/tree-sitter-dart.wasm` + `VENDORED_WASM_LANGS += + 'dart'` (R7b comment: commit sha + "wasm is the byte-copied + tree-sitter-wasms 0.1.13 artifact; kernel compiles the same-commit vendored + C — codegraph-kernel/grammars/dart"). No rebuild, no `tree-sitter + generate` — the shipped bytes ARE the reference. `copy-assets` already + globs `src/extraction/wasm/*.wasm`. MIT license. +- **External scanner: YES** — `src/scanner.c` PRESENT at the pinned commit. + It owns 7 external tokens: the 5 string-template char classes + (`_template_chars_*`), `_block_comment`, and + `_documentation_block_comment` — i.e. **`/** */` doc comments are + scanner-produced**; the vendored C must include scanner.c or every + string/comment shape breaks. +- **Vendor file list + sha256 (recorded at survey time from the commit clone):** + - `src/parser.c` `5a42b47abb4d494f125dbdee9138979248041689b1aa36355550fa3e28dcb8b8` + - `src/scanner.c` `07a7b7818b175e9460523e705dd88d20f7b5141bac95c593d4426e6d52284996` + - `src/tree_sitter/parser.h` `180b893c8734778fd32f372dfbc27bd6ad1cd2221f26150b31256ff6716320d2` + - `src/tree_sitter/alloc.h` `b29c1c9fb7cc82f58c84b376df1297d6e2737a1d655fd356db0859e3c29c2fea` + - `src/tree_sitter/array.h` `5bdf6ed1a78e3409fd443e085ca967a64c188a5d082aaf7f819bccd53a471c94` +- **crates.io `tree-sitter-dart` 0.2.0 is the nielsenko FORK — REJECTED** + (different lineage, 480 positional table mismatches per the batch-4 probe). + This supersedes the plan §4 long-tail row's "crates.io" route for dart. Do + not revisit unless the TS side migrates grammars. +- **Kernel side — vendored-grammar-C (the kotlin #1382 mechanism, second + use):** copy the three-file set above (parser.c, scanner.c, tree_sitter/*.h) + to `codegraph-kernel/grammars/dart/`; extend `codegraph-kernel/build.rs`'s + cc::Build to compile both C files with the grammar's own flags (its + checked-in `bindings/rust/build.rs` uses `-Wno-unused-parameter`, + `-Wno-unused-but-set-variable`, `-Wno-trigraphs`, msvc `-utf-8` — same set + kotlin vendored). langs.rs: + ```rust + extern "C" { fn tree_sitter_dart() -> *const (); } + // … + "dart" => Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_dart) }.into()), + ``` + plus `LANGUAGES` (langs.rs:24; `[&str; 15]` at survey time — sibling + batch-4 legs are landing concurrently, take whatever count is current) + += `"dart"`. + `__tests__/kernel-grammar-parity.test.ts:39` `GRAMMAR_LANGUAGES += 'dart'` + — the id-by-id ABI/kind/field-table compare against the vendored wasm is + the whole grammar gate here (both artifacts are same-commit by + construction; the parity test proves it stayed that way). +- **Staging:** wasm byte-copy + VENDORED_WASM_LANGS can land standalone + before the walker (full suite green; the "old-vs-new" dump gate degenerates + to cmp-identical since the bytes are identical — run it once on one repo as + a smoke test, expect zero). The kernel C vendor + build.rs + langs.rs + + grammar-parity row land with it or with the walker — same-commit from day + one. +- **Error incidence (both-arm reality — same grammar bytes on both arms by + construction; `error-sweep.cjs`, all `.dart` ≤1 MiB, `.git`/`node_modules`/ + `.dart_tool` skipped):** + + | Repo | files | hasError | % | phantom | + |---|---|---|---|---| + | dart-lang/shelf (small, server dart) | 99 | 10 | 10.10% | 0 | + | felangel/bloc (medium, Flutter + packages) | 616 | 21 | 3.41% | 0 | + | flutter/flutter (large, the framework) | 6,465 | 1,340 | 20.73% | 0 | + + Error classes (sampled + minimized to repros, `dart3-errors.txt` + + `error-diag.cjs`): **(a) empty object patterns** — `Init() =>` / + `case Init():` / `if (x case Init())` ALWAYS error (MISSING identifier in + `constant_pattern`); patterns WITH fields (`Point(x: var a)`) parse clean. + This is the modern sealed-class state-match idiom → it alone drives + flutter's 20.73% and bloc's flutter examples. **(b) unnamed `library;`** + (the dangling-doc idiom, dart-lang style guide) → MISSING identifier; + `library foo.bar;` is clean. **(c) null-aware collection elements** + (`[?x]`, `key: ?value`, Dart 3.8) → ERROR, often blowing the whole file + root. **(d)** mustache-template `.dart` files (bloc's `bricks/` + `{{name.snakeCase()}}`) — not real dart. **(e)** `augment class` (rare). + Everything else probed CLEAN, including records, non-empty patterns, switch + expressions, sealed/base/final/interface/mixin class modifiers, extension + types, super-params, one-line class bodies (NO kotlin-style phantom), + shebang `#!`, digit separators, and CRLF. **A non-ASCII IDENTIFIER errors + (`String séance`) — but that is invalid Dart anyway** (identifiers are + ASCII-only by spec); keep fixture identifiers ASCII and non-ASCII text in + comments/strings. +- **Deferral policy:** per-file `has_error()` → `defer:` (trust the flag); + sweeps with **`--max-deferral 0.3`** (covers flutter's 20.7% with headroom; + shelf/bloc sit far under). A deferral-rate JUMP vs the table is a walker + bug; the rate itself is grammar reality. + +## Architecture decisions + +1. **No preParse, no POST_PASS.** `dartExtractor` has no `preParse` hook + (languages/dart.ts — whole file) → `preParsedSource` (kernel/index.ts:108) + is a no-op; both arms parse raw bytes. `POST_PASSES` (kernel/index.ts:94) + is empty → `tryKernelExtractRaw` stays eligible. +2. **No dart framework resolver exists** (grep src/resolution/frameworks/ — + nothing lists dart; no Flutter resolver). BUT the **universal** `vue` and + `astro` resolvers (no `languages` list ⇒ applicable to every language, + frameworks/index.ts:110-118) carry `extract()` hooks → in a repo where + vue/astro is DETECTED, parse-worker.ts:92-99 forces `.dart` files onto the + decoded `extractFromSource` path (their extract() hooks no-op on `.dart` + content — transport differs, output must not). Pure dart/Flutter repos + ride the raw buffers path. All three gate repos are expected raw-path — + verify at sweep time; a mixed Vue+dart repo is the decoded-path smoke + check. +3. **One walker module** (suggest `codegraph-kernel/src/dart.rs`), registered + in langs.rs; per-file `has_error()` → `defer:`. Cribs: **kotlin.rs** for + the visitNode-hook-consumed constants + hook/scan interplay; **java.rs** + for the class-like scope stack, static-member refs, decorators, and + type-annotation walks. **Three surfaces have NO precedent in any ported + walker** and are transcription work from this doc: (a) `extractBareCall` + selector-walking (dart is the first callTypes=[] language), (b) the + sibling-body double-walk reproduction (§The double-walk), (c) the + constructor naming/skip hooks (`resolveName`/`isMisparsedFunction`). +4. **Wire notes (KERNEL_ABI_VERSION 2, layout.ts:20):** no dart extraction + path emits refs carrying `filePath` (verified across every ground-truth + dump — zero refs printed one) → **REF_FLAG_FILE_PATH (layout.ts:98) stays + unused, flag 0 on every ref** like swift/rust. `function_ref` = wire code + 200 (layout.ts:89). The node `decorators` wire field (layout.ts:56) is + **never populated for dart** (no `extractModifiers` hook — annotations are + `decorates` REFS only). The node `signature` field (layout.ts:55) is + **heavily used** (functions/methods AND hook-minted constants). +5. **MAX_FILE_SIZE (1 MiB) and skip dirs** (`.dart_tool`, `.pub-cache` — + extraction/index.ts:173) are orchestrator/TS-side and shared. + `isGeneratedFile` (generated-detection.ts:63-68) matches `.g.dart`, + `.freezed.dart`, `.pb.dart`, `.pbgrpc.dart`, `.chopper.dart` — those + files still EXTRACT normally but **skip the function_ref flush and the + value-ref pass** (tree-sitter.ts:647/:785); build_runner output is a huge + population in Flutter repos, so port the skip. +6. **Kind inventory** (what dart can emit): file, import, function, method, + class, enum, enum_member, type_alias, constant. **NEVER: field, property, + variable, struct, interface, trait, namespace, module.** Instance fields + mint NO nodes at all (§Constants); there is no namespace/package node + (no `packageTypes` hook — `library foo.bar;` is invisible); interfaces + don't exist as a dart concept (abstract classes are kind `class`). + +## Extractor config (languages/dart.ts — 380 lines, read it whole) + +Types: functionTypes=[`function_signature`] (:119); classTypes= +[`class_definition`] (:120); methodTypes=[`method_signature`, +`constructor_signature`] (:126); interfaceTypes=[] ; structTypes=[]; +enumTypes=[`enum_declaration`] (:129); enumMemberTypes=[`enum_constant`] +(:130); typeAliasTypes=[`type_alias`] (:131); importTypes=[`import_or_export`] +(:132); **callTypes=[] (:133 — extractCall NEVER runs for dart; all call refs +ride `extractBareCall` in the body walker)**; variableTypes=[] (:134 — +extractVariable never runs); extraClassNodeTypes=[`mixin_declaration`, +`extension_declaration`] (:135). nameField=`name` (:172), bodyField=`body` +(:173), paramsField=`formal_parameter_list` (:174 — DEAD, see +§Type-annotation refs), returnField=`type` (:175 — DEAD likewise). + +Grammar-shape facts the config leans on (all probed, `mini-cst.txt` / +`torture-cst.txt`): + +- **Signature/body split:** every function and method is a SIGNATURE node + (`function_signature` / `method_signature` / bare `constructor_signature`) + whose body is the **next named sibling** `function_body`. `function_body` + wraps either a `block` or a bare `=>` expression (arrow bodies have no + block child). The `async`/`async*`/`sync*` keyword is an anon child of + function_body. +- **Field truth table** (fieldNameForChild + behavior-pinned): + `function_signature.name` → identifier ✓ (formal_parameter_list is an + UNFIELDED child; return type is an unfielded `type_identifier`/`void_type` + BEFORE the name). `method_signature` has NO fields (its single child is + the inner signature). `getter_signature.name` / `setter_signature.name` ✓. + `constructor_signature` has **`name` fields on BOTH identifiers** (`name: + Widget`, `name: named` — childForFieldName('name') returns the FIRST = + the class) + `parameters:` field. `factory_constructor_signature` children + are UNFIELDED identifiers. `class_definition`: `name:` ✓, `superclass:`, + `interfaces:`, `body:` ✓. `extension_declaration`: `name:` (absent for + anonymous extensions), `class:` (the on-type), `body:` (extension_body). + `mixin_declaration`: **NO fields at all** (children: anon-ish named `mixin` + keyword node, identifier, on-types as bare type_identifiers, class_body). + `enum_declaration`: `name:` + `body:` (enum_body); `enum_constant.name` ✓. + `type_alias` has NO fields (both modern `typedef X = T` and legacy + `typedef void X(int)` are node `type_alias`). + `initialized_variable_definition`: `name:` + one-or-more `value:` fields + (the RHS postfix chain is FLATTENED into multiple value-fielded siblings). +- **In-class member shapes:** methods/getters/setters/operators/factories + and BODIED constructors are `method_signature > (function_signature | + getter_signature | setter_signature | operator_signature | + constructor_signature | factory_constructor_signature)` + sibling + `function_body`, both direct children of class_body. **BODILESS + constructors** (`Widget(this.size);`, `Widget._() : x = 0;`) wrap in a + `declaration` node instead (`declaration > constructor_signature [+ + initializers]`) — reached by the walker via plain recursion into + `declaration`. `const` constructors are `declaration > + constant_constructor_signature` and redirecting factories are + `declaration > redirecting_factory_constructor_signature` — **NEITHER is + in methodTypes → const ctors and `const factory X.r() = Impl;` are + INVISIBLE (no node, no refs)**. Fields are `declaration > + (static)? (final|const|type|var) > initialized_identifier_list | + static_final_declaration_list` (§Constants). +- **Statements/expressions:** calls have NO call node — a postfix chain is + FLAT siblings: `identifier selector selector …` where each `selector` + wraps `unconditional_assignable_selector` (`.name`) / + `conditional_assignable_selector` (`?.name`) / `argument_part > + arguments > argument*`. `new Foo(1)` IS a single `new_expression` + (children: unfielded type_identifier + arguments). `const Foo.bar(1)` in + EXPRESSION position is a `const_object_expression`; in a `const x = …` + declaration the const rides the declaration and the value is a plain flat + chain. Cascades are `cascade_section > cascade_selector + argument_part` + (NO selector node → invisible to everything, §Calls). Assignments are + `assignment_expression` with `left:` (an `assignable_expression`) and + `right:` fields. Locals are `local_variable_declaration > + initialized_variable_definition` (even without initializer). Lambdas are + `function_expression` (children incl. `body: function_expression_body`). + String templates: `string_literal > template_substitution` wrapping either + a full expression (`${…}`) or an `identifier_dollar_escaped` (`$name`). + +Hooks PRESENT (port each exactly — anchors into languages/dart.ts): + +- **visitNode (:144-157) — the constants branch.** `node.type === + 'static_final_declaration'` → nameNode = first namedChild of type + `identifier`; if present: valueNode = `nameNode.nextNamedSibling` (the + FIRST value child only — a flattened chain like `WidgetT(0)` captures just + `WidgetT`; a wrapped expression like `SHARED_MAX + 1` captures the whole + expression node); initValue = its text `.slice(0,100)` (UTF-16); + `ctx.createNode('constant', name, node, { signature: initValue ? \`= + ${initValue}${initValue.length >= 100 ? '...' : ''}\` : undefined })`. + Return **true** (consumed — even when nameNode missing? NO: name found is + required for createNode but the hook returns true for EVERY + static_final_declaration reached, node minted or not — transcribe the + early-return shape exactly: `if (nameNode) {…}; return true`). The + dispatcher then runs `scanFnRefSubtree(node, 0)` and never descends → + §Function-as-value for what still gets captured. Everything else → false. + **Reality of the node type (probed, `probe2-cst.txt`):** + `static_final_declaration` = a `final`/`const` declaration WITH an + initializer that is **top-level** (`const SHARED_MAX = 10;`, `final + typedTop = compute();`, typed or untyped, incl. multi-declarations `final + multiA = 1, multiB = 2;` → one node per list entry) **or class-level WITH + `static`** (`static const int K_MAX = 9;`, `static final sharedInst = + WidgetT(0);`). Instance `final untyped = 5;` / `final int size;` / any + `var`/typed-var member → `initialized_identifier` → **NO NODE** (dart + emits zero `field` nodes, ever). Top-level `var topVar = 5;` / `int + topTyped = 6;` → initialized_identifier → invisible too. Constants get + **no docstring, no visibility, no isExported** — signature only (pinned: + `/// Doc on num const?` is dropped). +- **resolveBody (:158-171)** — `function_signature`/`method_signature` → + `node.nextNamedSibling` if it's a `function_body`, else null (NOTE: a bare + `constructor_signature` — the declaration-wrapped bodiless ctor — takes the + OTHER branch: childForFieldName('body') → null → find + class_body/extension_body among children → null ⇒ named bodiless ctors + never walk a body, and their `initializers` sibling is left to plain + visitNode recursion). For class/mixin/extension nodes: standard `body` + field first (class_definition ✓, extension_declaration ✓), else the first + namedChild of type `class_body` | `extension_body` (mixin_declaration has + no body field → found by type). Used by extractClass/extractEnum body + resolution AND createNode's endLine extension (tree-sitter.ts:1322-1334 — + **LIVE and load-bearing for dart**: the comment there names Dart; a + method/function node's endLine extends to the sibling body's end, e.g. + `named` L123-125 spans its body). +- **getReturnType = extractDartReturnType (:80-92)** — ctor = dartCtorInfo + (§below): a validated ctor returns the CLASS name (named ctors, factories + → ret = enclosing class). Else sig = dartInnerSignature (:9 — + method_signature unwraps to function/getter/setter signature; **NOT + constructor/factory/operator** — those keep sig = the method_signature, + where the type search then finds nothing) → the FIRST namedChild of type + `type_identifier` → text, `.replace(/<[^>]*>/g,'')`, `.trim()`, last + `.`-segment, must match `/^[A-Za-z_]\w*$/`. Pinned: `Future` → + `Future` (type_arguments is a SIBLING node, so the strip is a no-op); + `List` → `List`; `WidgetT?` → `WidgetT` (nullable_type unwraps + positionally — the type_identifier is still first); `void` → undefined + (void_type ≠ type_identifier); `num`/`dynamic`/`Object` → themselves; + `T` (generic param) → `T` (leaks); **prefixed `other.OtherClass` → `other`** + (the prefix and the name are SEPARATE type_identifier leaves and the FIRST + is the prefix — the `.pop()` never sees a dot. BUG, PRESERVE); getters → + their type (`int get area` → `int`); setters → undefined; operators → + undefined (inner unwrap misses operator_signature); ctors → class name. +- **isMisparsedFunction (:177-188)** — dartCtorInfo != null AND ctorName === + className → **the UNNAMED constructor `Widget(this.size)` is skipped** (no + node; extractFunction/extractMethod still resolve+walk the body — which is + null for the declaration-wrapped form, so in practice nothing emits). + Named ctors/factories are kept. The `@override (T) m()` misparse (an + annotation swallowing a record return type leaves `m()` shaped like a + single-identifier constructor_signature) is NOT skipped — dartCtorInfo + validates ids[0] against the enclosing type name via dartEnclosingTypeName + (:38 — walks parents for class_definition/mixin_declaration/ + extension_declaration/enum_declaration and reads ITS name field) and + `reduce` ≠ `Action` → treated as the method it is (pinned: + `extract-probe4.txt` — method `reduce`, position starting AT `reduce`, + sig/ret undefined, decorates override intact). +- **getSignature (:189-208)** — method_signature unwraps to + function/getter/setter signature (NOT ctor/factory/operator); params = + find namedChild `formal_parameter_list`; retType = find namedChild + `type_identifier` | `void_type`; neither → undefined; result = `[retType + text + ' '] + [params text]`, trimmed. Pinned shapes: `void (int a, + String b)`; getter → `int` (retType only); setter → `(int v)` (params + only); generic return `Future load()` → **`Future ()`** (the + type_arguments are NOT included — retType is just the identifier); + full param text is a RAW source slice — named/optional brackets, defaults, + nested function-typed params all verbatim (`void ({int? named, required + WidgetT child, String note = 'x'})`); bodied named ctor (method_signature > + constructor_signature) → **undefined** (unwrap misses ctor; no direct + formal_parameter_list on method_signature); **bodiless named ctor + (declaration > constructor_signature) → `"()"`-style params-only sig** + (node IS the ctor signature; its formal_parameter_list is found by type) — + pin BOTH ctor sig shapes; operators → undefined. +- **getVisibility (:209-222)** — method_signature → unwrap to + function/getter/setter signature → its first `identifier` child; other + nodes → childForFieldName('name'). Name starts `_` → 'private', else + 'public'. QUIRKS, PRESERVE: **every constructor is 'public'** — for + method_signature-wrapped ctors the unwrap misses constructor_signature + (nameNode null → public); for bare constructor_signature the `name` FIELD + is the CLASS identifier (`Widget`, not `_`) → `Widget._()` is 'public' + (pinned). Operators → public. `_check`/`_privateMethod` → private ✓. + Classes/enums get visibility via the same hook at their extractors: + class_definition name field → `_Private` class would be 'private'. +- **isAsync (:223-233)** — nextNamedSibling is function_body → scan ALL its + children (anon included) for child.type === `'async'` → true. Pinned: + `async` → TRUE; **`async*` and `sync*` → FALSE** (different token text → + different anon type — generators are not "async"); bodiless (external/ + abstract) → false. Note the anon child's TYPE is exactly `async` (probed + via behavior). +- **isStatic (:234-243)** — node.type === 'method_signature' → scan ALL + children for type `'static'` → true; else false. `static WidgetT make()` + → true ✓ (the `static` keyword is an anon child of method_signature); + bare constructor_signature → false. Top-level functions → false. +- **resolveName (:244-260)** — dartCtorInfo: named ctor/factory → the ctor + name (`named`, `create`, `_`); unnamed ctor or non-ctor → undefined (falls + to extractName §below). +- **extractImport (:261-304)** — importText = trimmed full node slice; + moduleName = the URI string content: `library_import > + import_specification > configurable_uri > uri > string_literal` (else the + same chain under `library_export`), quotes stripped via + `.replace(/['"]/g,'')`. Returns {moduleName, signature} (no handledRefs) + → import NODE (name = the URI, e.g. `package:torture/other.dart`, + `dart:async`, `src/reexported.dart`) + the generic `imports` ref + (tree-sitter.ts:3183-3194) {from: file node (no namespace exists), name = + URI, line/col of the import_or_export node}. `as alias`, `show`/`hide` + combinators: IGNORED (not read). **`import 'x.dart' deferred as y;` is + INVISIBLE** — the deferred form's import_specification holds a bare `uri` + (NO configurable_uri wrapper) → hook returns null → falls through the + multi-import inline handlers (none match import_or_export) → no node, no + ref (pinned, `extract-mini.txt`). `part`/`part of`/`library` directives + are different node types (part_directive, part_of_directive, library_name) + in NO type list → invisible. None of the TS/py/rust/php/ruby binding + emitters (:3197-3234) fire for dart. +- **extractBareCall (:305-379)** — §Calls, the full matrix. + +Hooks ABSENT (the walker must NOT do these): `preParse`, `recoverMangledName`, +`classifyClassNode` (class_definition is always kind `class` — abstract/ +sealed/base/final/interface-modified classes included), `classifyMethodNode`, +`extractPropertyName`, `propertyTypes`, `fieldTypes`, `getReceiverType` +(never diverts extractFunction:1522; no receiver QNs; no owner-contains +:1799 — extension members ride the extension's own class node), +`isConst`, `isExported` (**undefined everywhere except the file node's +literal `false`**), `interfaceKind`, `extractPackage`/`packageTypes` (no +namespace node — top-level QNs are bare), `extractModifiers` (node +`decorators` never set), `synthesizeMembers`, `skipBodilessClass` (bodiless +`class Base {}` still mints — dart classes always have `{}` anyway), +`methodsAreTopLevel`, `resolveTypeAliasKind` (type_alias is always kind +`type_alias`). + +Registration: `EXTRACTORS.dart` (languages/index.ts:56), `FN_REF_SPECS.dart` +(function-ref.ts:394). + +## tree-sitter.ts branches (anchors as of `45a53eb`) + +### visitNode dispatch — what each dart node hits (ladder at 936-1303) + +| Node | Branch | Behavior | +|---|---|---| +| every node | visitNode hook first (:943) | `static_final_declaration` consumed (§Constants); handled → scanFnRefSubtree + STOP | +| every node | maybeCaptureFnRefs (:990) | fires for `arguments`/`assignment_expression`/`pair`/`list_literal`/`static_final_declaration` in visitNode context — the source of the file/class-attributed fn-ref twins (§double-walk) | +| `function_signature` | functionTypes:994 | methodTypes does NOT include it → **always extractFunction:1517**, even inside a class (isInsideClassLike && !methodTypes.includes → else-arm). In-class function_signatures occur only for ABSTRACT/bodiless methods, reached via their `declaration` wrapper (`declaration > function_signature`, probed) → **kind `function` contained by the class** (pinned: `AbstractT::mustImpl` is a function; the sibling `declaration > getter_signature` abstract getter stays invisible). skipChildren | +| `class_definition` | classTypes:1005 | no classifyClassNode → always extractClass:1679 (abstract/sealed/base/etc. included) | +| `mixin_declaration`, `extension_declaration` | extraClassNodeTypes:1022 | extractClass(node) → kind **`class`** | +| `method_signature`, `constructor_signature` | methodTypes:1027 | **NOT class-gated at the ladder** — extractMethod:1737 runs anywhere; its own gate :1747 (not class-like, no methodsAreTopLevel, no receiver) falls back: parent `object`/`object_expression`? (never in dart) else **extractFunction** — this is how extension-TYPE members and any stray non-class method_signature become plain `function` nodes (pinned: `extension type MetersT` → function `km`, bare QN) | +| `enum_declaration` | enumTypes:1064 → extractEnum:1914 | §Class family | +| `type_alias` | typeAliasTypes:1071 → extractTypeAlias:2890 | plain type_alias node; `getChildByField(node,'value')` → **null** (no fields) → **NO refs from the aliased type** (`typedef MapAlias = Map` emits nothing); returns false → children re-visited (function_type/formal_parameter_list children match nothing) | +| `import_or_export` | importTypes:1209 → extractImport:3170 | §Extractor config | +| `new_expression` | INSTANTIATION_KINDS:1255 (`new_expression` ∈ :354-361) | extractInstantiation:4610 → ctor field lookups null → namedChild(0) = type_identifier → `instantiates` ref from stack top; `<`-strip + last-`.`-segment apply (`new p.Foo()` → `Foo`). findAnonymousClassBody → always null for dart. Children still recursed | +| `function_body` (sibling of a consumed signature) | **no branch** | recursed → THE DOUBLE-WALK (§below) | +| `declaration` (fields, bodiless ctors) | no branch | recursed → constructor_signature hits methodTypes; initialized_identifier/list, constant_constructor_signature, redirecting_factory_constructor_signature, initializers, annotations-in-place: nothing | +| `getter_signature` / `setter_signature` BARE (top level) | no branch | **top-level getters/setters are INVISIBLE** (no node; their sibling function_body is visitNode-recursed where calls don't extract) — in classes they're method_signature-wrapped → methods | +| `const_object_expression`, `selector`, `cascade_section`, `assignment_expression`, `local_variable_declaration`, patterns, `extension_type_declaration`, `part_directive`, `library_name`, lambdas | no branch | recursed; calls only extract in the BODY walker (`extractBareCall` is not consulted by visitNode!) — §Calls for the consequences | +| `property_signature`/`method_signature` TS branch (:1282) | **shadowed** | method_signature is consumed at :1027 first; property_signature isn't a dart kind — branch unreachable | + +### THE DOUBLE-WALK (sibling bodies) — reproduce it exactly + +Because bodies are SIBLINGS, every signature-consuming extractor walks its +body via resolveBody, and then the ENCLOSING loop (program level, class-body +loop, or an outer visitFunctionBody) visits the same `function_body` node +again as an ordinary child. What fires on each pass: + +- **Pass 1 (visitFunctionBody, attributed to the function/method):** the + full body matrix — extractBareCall calls, instantiates, static-member + refs, nested named functions (:5245), fn-ref capture (:5137). +- **Pass 2a (visitNode recursion — program/class-body sibling visit):** ONLY + the visitNode-dispatched branches: `new_expression` → **instantiates from + the FILE (top level) or CLASS (class body)**; nested `function_signature` + → **a SECOND extractFunction** (functionTypes:994) minting a DUPLICATE + node — same (kind, name, line) ⇒ **the SAME node id** — whose parent is + the file/class (contains edge from file/class; QN `localFn` at top level, + `Holder::methodLocal` in a class) and whose own body walk re-emits its + refs attributed to the duplicate; maybeCaptureFnRefs:990 → **fn-ref + candidate twins from the file/class**; `static_final_declaration` never + occurs inside bodies (locals are initialized_variable_definition) — no + constant dupes. Bare calls, static reads, cascades: NOTHING (no + extractBareCall/extractStaticMemberRef in visitNode). +- **Pass 2b (outer visitFunctionBody sibling visit — a LOCAL function's body + seen by ITS enclosing body walker):** the full body matrix again, + attributed to the ENCLOSING function — bare calls inside a local fn hence + emit from the local fn (pass 1) AND from the enclosing fn (pass 2b) AND + from the duplicate local fn (pass 2a's own body walk). + +Pinned interleaves (`extract-probe2.txt`, transcribe as parity expectations): + +- Top-level `hostFn` with local `localFn { inner(n); }` and local + `localWithNew { new Holder(1); }`: + nodes `hostFn::localFn` (contained by hostFn) … then `localFn` (bare QN, + contained by file, SAME id) after the pass-2a revisit; refs in order: + `calls inner from=localFn` (pass 1 of nested extract), `calls inner + from=hostFn` (pass 2b), `calls localFn from=hostFn`, `instantiates Holder + from=localWithNew`, `instantiates Holder from=hostFn`, `calls localWithNew + from=hostFn`, — then the program-level revisit: `calls inner from=localFn` + (2nd node's walk), `instantiates Holder from=localWithNew` (2nd), + `instantiates Holder from=file`. +- In-class `useNew` with a local `methodLocal { h.touch(); }` and `new + Holder(2)`: `instantiates Holder from=useNew`, `calls h.touch + from=methodLocal`, `calls h.touch from=useNew`, `calls methodLocal + from=useNew`, then the class-body revisit: `instantiates Holder + from=class:Holder`, `calls h.touch from=methodLocal` (2nd) — and node + `Holder::useNew::methodLocal` + duplicate `Holder::methodLocal` (kind + function both, same id). +- fn-ref twins: `register(seedValue)` in a top-level fn → `function_ref + seedValue from=refTaker` AND `from=file:…` (flush order: all in-scope + candidates first, then the revisit's file/class twins — capture order); + in a class method → `from=method:wire` AND `from=class:H` twins + (`fnref2.dart` pin). +- Per-declaration order: ALL of a function's pass-1 refs come before its + pass-2a refs, which come before the NEXT declaration's refs (the program + loop visits signature then body then the next signature). Same per class + member inside class_body. + +**Dedupe reality:** node dupes share an ID (`generateNodeId` has no +uniquifier) — two node rows, two contains edges; downstream the store +last-writer-wins by id, but the WIRE/parity dump carries both rows — +byte-parity requires emitting both, in order. The kernel `node_ids` vec +must therefore NOT self-dedupe: emit exactly what TS emits. + +### Node creation, IDs, qualified names + +- createNode (:1308): id = `generateNodeId(filePath, kind, name, + startRow+1)` = `` `${kind}:${sha256(`${filePath}:${kind}:${name}:${line}`).hex.slice(0,32)}` `` + (tree-sitter-helpers.ts:18-30). FILE node id = literal `file:${filePath}` + (:509), name = basename, qualifiedName = filePath, endLine = + `source.split('\n').length`, isExported false. +- **endLine extension (:1322-1334) is LIVE** for function/method kinds: + resolveBody's sibling function_body extends endLine past the signature + (`named` L123→125; `bodyShapes` L60→96). Class/enum/etc. spans are their + own node extents. +- contains edge from nodeStack top for every created node (:1363); + extractModifiers merge (:1355) is a no-op (hook absent); + captureValueRefScope (:1374). +- qualifiedName = nodeStack names joined `::` (buildQualifiedName:1447; file + excluded; namespacePrefix always empty outside C/C++). No package node → + top-level QNs are bare; members `WidgetT::render`; nested + `WidgetT::useNew::methodLocal` (and the duplicate's shallower + `WidgetT::methodLocal` — §double-walk). +- isInsideClassLikeNode (:1486): stack-top kind ∈ {class, struct, interface, + trait, enum, module} — for dart that means class (incl. mixins/extensions) + and enum. +- Node position = the SIGNATURE node (functions/methods): `externalFn` starts + col9 (the `external` keyword sits OUTSIDE function_signature); the + `@override (T) m()` misparse starts at `m` (col16 pin); constants sit at + the static_final_declaration (name start), enum members at the + enum_constant, imports at import_or_export. + +### extractFunction / extractMethod (:1517 / :1737) + +- extractFunction: no receiver hook → never diverts. Name via extractName + (:90): resolveName (ctor names) → nameField `name` (function_signature ✓) + → the method_signature inner-unwrap fallback (:148-167 — the dart-specific + branch: find inner function/getter/setter/constructor/factory_constructor + signature, take its first `identifier` child) → first + identifier/type_identifier child (:178-189) → ``. +- **Operator methods: name = ``** — operator_signature is NOT in + the :148 inner list and method_signature has no identifier children → the + fallback finds nothing → createNode('method', '', …) — the + name is truthy so the node IS minted (extractMethod has no `` + skip, unlike extractFunction:1549 which only guards the extractFunction + path — and even there `` only occurs for arrow/function_ + expression types, not dart signatures). Pinned: `WidgetT operator +(…)` → + method `` vis=public sig/ret undefined, its param/return + type_identifiers still emitted as references FROM it, body calls + attributed to it. Multiple operators in one class → same name, different + lines → distinct ids. +- extractMethod extras {docstring, signature, visibility, isAsync, isStatic, + returnType}; extractFunction adds isExported (undefined). Then + extractTypeAnnotations (:1594/:1816 — §Type-annotation refs), then + extractDecoratorsFor (:1599/:1819 — §Decorators), then push + body walk + via resolveBody + pop. +- Bodiless-in-class function_signature (abstract members) → extractFunction + → **kind `function`** node with class-prefixed QN (pinned `AbstractT:: + mustImpl`); resolveBody → nextNamedSibling is NOT a function_body (next + member) → no body walk. Abstract GETTERS (`int get abstractGetter;`) are + bare getter_signatures → invisible entirely. +- extractMethod's fallback for non-class method_signatures (extension types, + hypothetical top-level method_signature) → extractFunction (:1760) after + the object-literal parent check (:1751 — never true in dart). + +### The class family — extractClass / extractEnum + +- **extractClass (:1679)** for class_definition + mixin_declaration + + extension_declaration: resolvedBody via hook (class_body/extension_body); + no skipBodilessClass. extras {docstring, visibility (name-underscore + rule), isExported undefined}. extractInheritance (§below) BEFORE the body + walk; extractCsharpPrimaryCtorParamRefs — **WARNING, NOT a no-op by + language gate**: :5938 checks `this.language !== 'csharp'` → returns + early ✓ (cheap early-out — port as a no-op). extractDecoratorsFor (§Decorators: + `@immutable class` → decorates from the class). Push, visit body + namedChildren via visitNode, pop. +- Extension names: `extension WidgetTExt on WidgetT` → name field → + `WidgetTExt`; **anonymous `extension on String` → the extractName + fallback finds the FIRST type_identifier = the ON type → a class node + named `String`** (pinned — members become `String::anonExt`). The + extended type is otherwise INVISIBLE (no ref — extractInheritance matches + nothing on extension/mixin nodes). +- Mixins: `mixin MixA on BaseT` → class `MixA`; the `on` types are bare + type_identifier children matching NO inheritance clause → **no refs**. + `mixin MixB implements DrawT` → the `interfaces` child DOES match → + implements DrawT ✓. +- **extractEnum (:1914)**: body REQUIRED (enum_body via `body` field — + present). extras {docstring, visibility, isExported undefined}. + extractInheritance on enum_declaration: `interfaces` child → implements ✓; + **the `mixins` child is a DIRECT child of enum_declaration (no superclass + wrapper) and matches NO clause → `enum StatusT with MixB` emits NOTHING + for the mixin** (pinned — the class-side mixin handling lives inside the + `superclass` branch only). Body loop (:1941-1950): `enum_constant` ∈ + enumMemberTypes → extractEnumMembers; everything else (declaration-wrapped + fields/const ctors → nothing; method_signature getters/statics → + extractMethod with the enum pushed) → visitNode. +- **extractEnumMembers (:1958)**: `getChildByField(node,'name')` — the + `name` field EXISTS on enum_constant → **ONE enum_member node per + constant, positioned at the ENUM_CONSTANT node** (extent covers `ok(200)` + — id line = the constant's line), then RETURN. Ctor arguments + (`argument_part`) are NEVER walked → no refs from enum-constant + arguments. The identifier-scan fallback (:1967) is dead for dart. +- Inheritance — extractInheritance (:5291), the dart rows (probed): + - `superclass` child (class_definition only) → **the dart branch + (:5368-5393)**: for each namedChild of the superclass node — direct + `type_identifier` → **`extends`** ref; a `mixins` child → one + **`implements`** ref per `type_identifier` inside. `class WidgetT + extends BaseT with MixA, MixB` → extends BaseT + implements MixA + + implements MixB; `class OnlyMix with MixA {}` → superclass holds ONLY + mixins → implements MixA, NO extends (pinned). Generic supertypes: + the type_identifier is the base, `type_arguments` a sibling → + `extends Base` clean. Position = each type_identifier. + - `interfaces` child (:5437-5459, class + enum): targets = its + namedChildren (no type_list in dart) → one **`implements`** per child, + name = FULL child text (children are type_identifiers; a generic + `implements Comparable` would ride the type_identifier + sibling + type_arguments shape → name `Comparable`). + - Order: extends+mixins first (superclass child precedes interfaces in + source), then interfaces — all BEFORE decorates and body members + (pinned ref order: extends BaseT, implements MixA, implements MixB, + implements DrawT, decorates immutable, then member refs). + - The python `argument_list`-under-`class_definition` branch (:5463) + shares dart's class node TYPE — but a dart class_definition never has + an argument_list child → dead; port nothing but know why it's safe. + - Extensions/mixins: extractInheritance runs but nothing matches (`on` + types are bare type_identifiers) — zero refs. + +### Constants (the visitNode hook) — and what NEVER minted + +Covered in §Extractor config. Emission pins (`extract-torture.txt`): +top-level `const SHARED_MAX = 10` → constant, QN bare, sig `= 10`; +`final DERIVED_VAL = SHARED_MAX + 1` → sig `= SHARED_MAX + 1` (whole +expression node); `final typedTop = compute()` → sig `= compute` (flattened +chain → FIRST value child only); `static final sharedInst = WidgetT(0)` → +constant under the class, sig `= WidgetT`; multi-declarations → one node +each with own columns. **NO nodes ever**: instance fields (typed/untyped/ +late/var), `static var`, top-level var/typed vars, top-level getters/ +setters, const constructors, redirecting factories, extension_type +containers, `part`/`part of`/`library`/deferred imports. **Initializer +side-effects:** hook-consumed constants' initializers are NOT walked → no +calls/instantiates from them (only scanFnRefSubtree capture — §fn-refs); +initialized_identifier fields' initializers ARE recursed by visitNode but +only INSTANTIATION_KINDS fires there → `int counter = 0;` emits nothing, +but a field `final w = new Widget();` would emit `instantiates Widget` from +the CLASS (and a top-level `var w = new Widget();` from the FILE). No +static-member refs from any of these contexts (body-walker only). + +### Calls — extractBareCall (dart.ts:305-379) in the body walker (:5159-5173) + +Only visitFunctionBody consults extractBareCall; the ref is {from: nodeStack +top, name, line/col of the MATCHED node (the selector/const-object node — +NOT the chain head)}. The dart matrix (all pinned in extract-torture.txt / +extract-mini.txt): + +| Source shape | Matched node | Emitted `calls` ref | +|---|---|---| +| `helper(count)` | selector>argument_part; prev = identifier | `helper` at the selector position | +| `WidgetT(1)` | same | `WidgetT` (constructor = plain capitalized call; the resolution side's CONSTRUCTS_VIA_BARE_CALL — name-matcher.ts:918 — depends on exactly this shape) | +| `obj.method(x)` | args selector; prev = `.method` selector; accessorPrev = identifier | `obj.method` (receiver kept, lowercase or not) | +| `ConfigT.load()` | same | `ConfigT.load` **+ a `references ConfigT` static-member ref from the `.load` selector (§Static-member) — the double emission** | +| `WidgetT.named(3)` | same | `WidgetT.named` + references WidgetT | +| `other.OtherClass()` (prefixed ctor) | same | `other.OtherClass` | +| `this.own()` / `super.parent()` | args selector; prev = `.own` selector; accessorPrev = `this`/`super` node (not identifier) | bare `own` / `parent` | +| `a.b.call3(x)` (2+ hops) | accessorPrev = another non-argpart selector | bare `call3` | +| `FactoryT.create().run()` | outer args selector; accessorPrev = inner argument_part selector | **`FactoryT.create().run`** — the #750 re-encode via dartCalleeOfArgPart (:100-116): innerCallee `FactoryT.create` is `/^[A-Z]/` → `` `${innerCallee}().${method}` ``; plus the inner `FactoryT.create` ref from its own selector; plus references FactoryT | +| `WidgetT.named(3).chainTail()` | same | `WidgetT.named().chainTail` + `WidgetT.named` + references WidgetT | +| `lower().chain()` | innerCallee `lower` lowercase | bare `chain` + `lower` | +| `xs.map((e) => …).toList()` | innerCallee `xs.map` lowercase | bare `toList` + `xs.map` | +| `w?.render()` | conditional_assignable_selector | `w.render` — **`?.` is encoded exactly like `.`** | +| `y2..add(1)..add(2)` (cascades) | cascade_section (argument_part NOT inside a selector) | **NOTHING — cascade calls are completely invisible** | +| `new WidgetT(2)` | new_expression → INSTANTIATION branch :5145 FIRST | `instantiates WidgetT` (extractBareCall's new_expression arm :363-367 is DEAD — the else-if never reaches it); args still recursed | +| `pad(const EdgeInsetsT.all(8.0))` | const_object_expression :369-376 | `EdgeInsetsT.all` at the CONST node position (typeId + '.' + nameId; type-only form → `EdgeInsetsT`); children recursed after | +| `generic(5)` | args selector (type args ride argument_part) | bare `generic` | +| `await fetch()` | recursion through unary/await_expression | `fetch` at the selector | +| `throw StateError('bad')` | recursion | `StateError` | +| `'sum ${a + compute()}'` | template_substitution recursion | `compute` (interpolation calls EMIT); `$name` → identifier_dollar_escaped → nothing | +| local-lambda body `final lam = (int a) { helper(a); }` | function_expression recursed transparently | `helper` attributed to the ENCLOSING function; `lam(5)` → `lam` | +| ctor initializers (`: size = seed()`), enum-constant args (`ok(200)`), default param values, hook-consumed constant initializers | never body-walked | NOTHING | + +extractCall (:3684), LITERAL_RECEIVER_TYPES (:373-388), SKIP_RECEIVERS, the +parenthesized-conversion regex (:4530), template-strip — ALL UNREACHABLE for +dart (callTypes empty). Do not port them. + +### Static-member / value-read refs — dart branch (:4759-4767), STATIC_MEMBER_LANGS:346 + +Called from the body walker only (:5218). The DART-SPECIFIC branch (the +shared MEMBER_ACCESS_TYPES path is never reached — it returns first): +node.type === `selector` AND it has NO `argument_part` child AND +previousNamedSibling is an `identifier` matching `/^[A-Z][A-Za-z0-9_]*$/` → +`references ` from the enclosing symbol at the +**IDENTIFIER's (receiver's) position** (pushStaticMemberRef :4800). Pins: + +- `ConfigT.setting;` → references ConfigT (value read). +- **`ConfigT.load()` → references ConfigT TOO** — the `.load` selector has + no argument_part (the args are the NEXT selector) and the dart branch has + NO callee-of-call skip → every capitalized-receiver method call + double-emits (references + calls). PRESERVE — this is the single biggest + ref-volume quirk on real repos. +- `util.Config.load()` → nothing (first selector's prev = lowercase `util`; + later selectors' prev = selectors). +- `this.x` → prev is a `this` node → nothing. Case patterns (`case + ColorT.blue:`) → `constant_pattern > qualified` shape, no selector → + NOTHING (pinned gap). Cascade sections → no selector → nothing. + Class-field/constant initializers and visitNode contexts → never called. + +### Type-annotation references — dart ∈ TYPE_ANNOTATION_LANGUAGES (:5753), the dart branch (:5819-5833) is LIVE + +For every function/method node, extractTypeAnnotations takes the DART path: +sig = node; if node.type === 'method_signature' → sig = first inner +function/getter/setter/constructor/factory_constructor signature (**?? node +— operators fall back to the method_signature itself**). Then +`extractTypeRefsFromSubtree(sig)` (:6090) — one `references` ref per +`type_identifier` LEAF in the whole signature subtree, skipping +BUILTIN_TYPES (:5768-5782), at each leaf's position. Consequences (pinned): + +- Return types AND param types in one sweep: `void render(CanvasT c)` → + references CanvasT; `List listRet(Map m)` → + **references List** (List is NOT builtin!), WidgetT, **Map** (not + builtin), WidgetT. +- BUILTIN suppressions that matter for dart: `int`, `double`, `String` + (capital-S — the Scala row), `Boolean`, `bool`, `float`, `long`, `char`. + **NOT suppressed (noise refs, PRESERVE): `num`, `dynamic`, `Object`, + `List`, `Map`, `Set`, `Future`, `Stream`, `Iterable`, `T`-style generic + params.** `void` is a `void_type` node → structurally silent. +- Generic declarations self-reference: `T generic(T v)` → **references T + ×3** (return + the `` type_parameters + the param — all + type_identifier leaves in the signature subtree). +- Prefixed types: `other.OtherClass` → references `other` AND `OtherClass` + (two leaves). +- Ctors: bodied named ctor (method_signature > constructor_signature) → sig + = constructor_signature → param types emit (`Widget.named(WidgetT w)` → + references WidgetT); `this.`-params (constructor_param) hold no + type_identifier → nothing. Bodiless declaration-wrapped ctors: extractMethod + runs on the bare constructor_signature → sig = node → same. +- Getters: references from the getter's TYPE (suppressed if builtin — + `int get area` → nothing; `WidgetT get w` → references WidgetT). +- extractVariableTypeAnnotation (:6074) needs a `type_annotation` child — + **no such node type in this grammar → dead**; the body-walker + `variable_declarator` branch (:5230) — no such node type → dead. Local + `WidgetT w = …;`, field types, `is`/`as` types, collection type args in + bodies → **NO refs** (pinned). + +### Decorators — dart annotations DO emit `decorates` via the SIBLING scan + +Dart annotations are `annotation` (with `name:` field; args form has an +`arguments` child) or `marker_annotation`-free — probed: both `@override` +(bare) and `@Deprecated('x')` (args) are node type `annotation`, PRECEDING +SIBLINGS of the declaration they decorate (inside program / class_body). +extractDecoratorsFor (:4897) is called for classes (:1710), functions +(:1599), methods (:1819) — NOT for hook-minted constants, enums(!), or +type aliases (extractEnum/extractTypeAlias never call it — an annotated +enum emits nothing). Mechanics for dart: + +- Scan #1 (direct children :4976-4988): annotations are never children of + the signature → inert (no `modifiers` node either). +- Scan #2 (preceding siblings :5002-5023): walk BACKWARD from the + declaration; `annotation` is in the accepted set (:5017); stop at the + first non-annotation sibling. consider(): target = first namedChild of + accepted types → the `identifier` (`override`, `deprecated`, `pragma`, + `immutable`, `Deprecated`) → `<`-strip + last-`.`-segment (`@ui.Widget` + style would strip to `Widget`) → **`decorates` ref {from the decorated + node, name, line/col of the ANNOTATION node}**. With-args annotations + emit their NAME; the argument expressions are never visited (no refs from + `@Deprecated('use other')`'s string). +- **Stacked annotations emit in REVERSE source order** (the backward walk): + `@Deprecated('x')\n@pragma('vm:entry-point')\nvoid f()` → decorates + `pragma` FIRST, then `Deprecated` (pinned). +- For a method: the previous member's function_body (or any declaration) + breaks the chain correctly. The annotation-BETWEEN-doc-and-decl also + breaks the DOCSTRING chain (§Docstrings). +- Bodiless ctors (declaration-wrapped): extractMethod runs on + constructor_signature whose PARENT is the `declaration` node — the + backward scan runs over declaration's children (constructor_signature is + namedChild(0) → declIdx 0 → no siblings scanned) → an annotation before + the declaration attaches to NOTHING. Annotated fields likewise emit + nothing (no extractor runs). + +### Docstrings (tree-sitter-helpers.ts:95-127) — dartdoc is KEPT, both forms + +Dart comment node kinds: `comment` (`//` and `/* */`) and +`documentation_comment` (**`///` AND `/** */`** — the block form is +scanner-produced, external `_documentation_block_comment`). BOTH kinds are +in getPrecedingDocstring's accepted set → **`///` runs, `/** */` blocks, and +plain `//` comments all become docstrings and accumulate together** (pinned: +`/// Line doc kept.` + `// Plain comment also kept?` → joined two-line doc; +`/** Block dartdoc kept. */` → kept). cleanCommentMarkers: the `/*`-open +strip + `^\/\/[/!]?\s?` + `^\s*\*\s?` gm strips fire — **all `gm` strips +ride `js_multiline_strip` in docstring.rs (#1329 CRLF semantics) — call the +shared code, port nothing**. DOCSTRING_WRAPPER_TYPES contains no dart kinds +→ no anchor climbing. **An `annotation` between the comment run and the +declaration BREAKS the chain** (pinned: `/// Broken by annotation.` +`@deprecated` `void annotated()` → doc undefined — the dominant real-world +loss since `@override` is ubiquitous). Docstrings attach to: functions, +methods (incl. `` operators), classes/mixins/extensions, enums, +type aliases. NOT to: hook-minted constants (extra carries only signature — +pinned drop), enum members, imports, the file node. No comment-gluing into +import extents (probed — import_or_export ends at the `;`). + +### Value-reference edges (:398-931) — dart IS in VALUE_REF_LANGS (:401) + +Port the full machinery (crib java.rs/kotlin.rs): `CODEGRAPH_VALUE_REFS=0` +kill; MAX_VALUE_REF_NODES = 20,000 caps both DFS passes; isGeneratedFile +skip (`.g.dart` and friends!). + +- **Targets** (captureValueRefScope:735): kind constant|variable, name ≥3 + chars AND `/[A-Z_]/`, parent id prefix ∈ {file:, class:, module:, struct:, + enum:}. Dart mints ONLY `constant` (kind variable never occurs) → targets + = hook constants under file: or class: (an enum-scoped `static const` + would ride enum:). `lowercase_const`/`plain`/`low` (no capital, no `_`) → + not targets; `kLimit`/`typedTop` (embedded capitals) → targets. +- **Reader scopes** (:764): every function/method/constant node (dart has no + variable nodes). **The Dart sibling-body pull (:883-892) is LIVE and + load-bearing**: a function/method reader scope's node is the SIGNATURE — + its `nextNamedSibling`, when of type `function_body` (or `block`), is + pushed into the reader DFS; without it every method/function body read + would be invisible. Constants' reader subtree is the + static_final_declaration itself (initializer reads: pinned + `DERIVED_VAL → SHARED_MAX` edge); their nextNamedSibling is another + static_final_declaration (multi-lists) → not pulled ✓. Duplicate local-fn + nodes (§double-walk) are ALSO reader scopes — same reads, both scopes + (dedupe is per (scope,target), scopes differ → **duplicate value-ref + edges from the twin scopes when a local fn reads a target** — include the + shape in a fixture if a local fn reads a constant). +- **Shadow prune** (:803-878): the dart declarator cases (:844-850) — + `static_final_declaration` (the target itself), `initialized_identifier` + (fields/top-level vars), `initialized_variable_definition` (locals) — each + bumps its first `identifier`-typed namedChild. **Uninitialized locals + (`int DERIVED;`) still bump** (pinned prune); a method-local `final + SHARED_MAX = 1;` prunes the file-wide target (pinned). **`assignment_ + expression` is NOT a prune case** (the :829 `assignment` case is + python's — the swift-lesson check comes out DEAD for dart): an + assignment-only rebind never bumps, and `low = 5;` style writes are + invisible to the prune. fileScopeValueCounts: conditional double-defs + don't occur in dart (const redefinition is illegal) — counts are 1 each. +- **Emission** (:880-930): per reader scope, stack-DFS (namedChildren pushed + in order, POPPED — reverse-source-order visitation; edge order follows); + match node type `identifier` (:907 — `constant`/`name`/`simple_identifier` + never occur in dart trees). Any identifier text mapping to a live target + emits — including the member half of `Table.COL_LIMIT` navigation + (pinned) and `${SHARED_MAX}` interpolations (template_substitution > + identifier). **`$SHARED_MAX` (no braces) is `identifier_dollar_escaped` — + NOT accepted → no read** (pinned asymmetry). Skip self-id + same-name, + dedupe per (scope,target) → EDGE {kind:'references', + metadata:{valueRef:true}}, appended AFTER all other edges (last rows of + every dump). + +### Function-as-value capture (#756) — DART_SPEC (function-ref.ts:310-320) + +idTypes = {`identifier`} (bare identifiers ARE candidates). dispatch: +`arguments` → args; `assignment_expression` → rhs (field `right`); `pair` → +value (field `value`); `list_literal` → list; `static_final_declaration` → +varinit (NO field → last-named-child rule :471-487: requires ≥2 named +children; the name-field guard is inert — no `name` field on +static_final_declaration). layers: `argument` → null (fan out). NO special, +NO unwrap, NO ungatedModes, NO addressOfOnly. Pins: + +- `register(topLevel)` → candidate via arguments→argument→identifier ✓. +- **Named arguments are NOT captured**: `reg(cb: onlyNamed)` → the child is + `named_argument` — not in layers, not an idType → NOTHING (pinned, + `namedarg.dart`). Flutter's `onPressed: handler` idiom is therefore + invisible — bug-for-bug, do NOT "fix" in the port (candidate future + accuracy PR: add `named_argument`/`label` handling TS-side first). +- `obj.cb = assigned` → rhs capture ✓; param-storage skip (:425-443) + compares the LHS's trailing identifier to the rhs text — `this.cb = + assigned` kept (cb ≠ assigned), a hypothetical `this.cb = cb` skipped. + `cb = selfStore` where selfStore is a PARAMETER shadowing a same-named + function → captured + gate-passed (false positive, PRESERVE — pinned). +- `[topLevel, blockDoc]` list ✓ (locals' list_literals capture too — the + dispatch fires wherever the node is walked); `{'k': topLevel}` pair ✓; + `final aliasTop = aliased;` top-level/static → varinit bare-identifier ✓ + (pinned from=file / from=class); a LOCAL `final alias = topLevel;` → + initialized_variable_definition NOT in dispatch → not captured. +- obj.method member values (`final g = obj.method`) → the last child is a + selector → normalizeValue [] → nothing (no member special for dart). +- Capture points: visitFunctionBody:5137 (bodies), visitNode:990 (the + §double-walk twins from file/class scope), scanFnRefSubtree (hook-consumed + constant initializers — halts at `function_expression` :609, so lambdas + inside a constant's initializer don't leak candidates). +- **Flush gate (:639-728): effectively "defined in this file" ONLY** — dart + import refs are URIs (`package:foo/util.dart`, `dart:async`) which match + neither SIMPLE_NAME nor QUALIFIED_IMPORT (`:` and `/` excluded) → + importedNames is always EMPTY for dart. definedHere = same-file + function/method NAMES — which includes single-letter method names (a + method `a` gates any bare arg `a` — pinned false positive, PRESERVE) and + ``. No `this.`/`::` forms are ever produced (no special) → + every candidate takes the definedHere gate. Dedupe `${fromNodeId}|${name}` + → survivors as {referenceKind:'function_ref'} (wire 200) appended after + all walk refs — in-scope candidates first, then the double-walk + file/class twins (capture order). + +### visitFunctionBody (:5129-5286) — dart rows + +- maybeCaptureFnRefs (:5137) per node. +- callTypes (:5143) — empty, dead. INSTANTIATION_KINDS (:5145) → + new_expression → extractInstantiation (children still recursed — a nested + `new Foo(bar())` emits both instantiates and the inner call). +- **extractBareCall (:5159-5173)** — §Calls. No skip/return → children + always recursed after (inner chain selectors each get their own shot). +- extractStaticMemberRef (:5218) — §Static-member. +- variable_declarator branch (:5230) — dead (no such kind). +- Nested `function_signature` (:5245) → named → extractFunction → local + functions as `function` nodes (QN nested via stack), THEN the enclosing + walker also re-walks the local's sibling body (§double-walk pass 2b) and + the outer visitNode revisit re-extracts it (pass 2a). +- classTypes/enumTypes in bodies (:5255/:5268) — grammatically impossible in + dart (no local classes/enums) → dead. +- Recursion is transparent through if/for/while/switch statements (but case + PATTERN internals use pattern node kinds — `constant_pattern > qualified` + — where neither extractBareCall nor static refs match → enum reads in + case labels are invisible, pinned), try/catch, await/unary, throw, + string templates, function_expression lambdas (calls attribute to the + enclosing symbol), collection literals (`[…]` type args silent). + +### Misc shared paths + +- Positions: `line = startPosition.row + 1`, `column = + startPosition.column` — **UTF-16 code units** (textutil::col16), as are + startIndex/endIndex substrings (getNodeText everywhere: signatures, + constant initializers `.slice(0,100)`, import signature `.trim()`). +- extract() wrap (:454-568): file node → (no package hook → no namespace) → + root visitNode walk → flushFnRefCandidates → flushValueRefs → pop. Table + order: nodes in creation order (INCLUDING double-walk duplicates); contains + edges interleaved with creation; value-ref EDGES appended last; + walk-order refs then function_ref refs at flush. Store/harness are + rowid-order-sensitive — reproduce exactly. +- **CRLF: probed clean end-to-end** — the CRLF-converted torture fixture + extracts BYTE-IDENTICALLY to LF (`extract-crlf.txt` diff-0 after filename + normalization). dart.ts has NO multi-line regexes (`/<[^>]*>/g`, + `/^[A-Za-z_]\w*$/`, `/['"]/g`, `/^[A-Z]/` are all single-token); the only + CRLF-sensitive shared path is cleanCommentMarkers' `gm` strips → + `js_multiline_strip` in docstring.rs. Multi-line signature slices and + ≥100-char initializer captures include raw `\r` bytes on CRLF sources — + identical on both arms by construction (same source slice). +- Defer policy: per-file `has_error()` → `defer:`; expected incidence per + §Grammar prep (3.4–20.7%); `--max-deferral 0.3`. No phantom class found — + but defer on the FLAG regardless (never on ERROR-node presence). +- Language display name `Dart` (grammars.ts:626) — cosmetic only. + +## Frameworks & synthesis consumers (stay TS-side — pin the walker's output contract) + +- **No dart framework resolver, no dart callback-synthesizer pass, dart ∉ + CC_LANGUAGES** — grep-verified. Nothing consumes dart node EXTENTS beyond + the generic paths; the endLine extension still matters for context slices + and explore output. +- **Resolution contracts the walker's output feeds** (behavior to hold + steady, verified at 45a53eb): + - `CONSTRUCTS_VIA_BARE_CALL` (name-matcher.ts:918) — bare capitalized + `calls WidgetT` refs resolve as constructions; depends on ctor calls + staying PLAIN calls refs (dart emits `instantiates` ONLY for + `new_expression`). + - `matchDottedCallChain` (name-matcher.ts:2147-2166, dart listed) — + consumes the `Foo.create().run` re-encode + the method nodes' + `returnType` (extractDartReturnType's class-name-for-ctors rule is what + makes `WidgetT.named(3).chainTail()` resolve — #750/#645). + - Local-variable receiver inference (name-matcher.ts:1202-1209) — regexes + over raw source (`var lg = Logger(`, `Logger lg,`) — no extraction + dependency beyond node names. + - CHAIN_LANGUAGES (resolution/index.ts:42) includes dart — same inputs. + - `matchMethodCall`'s bare-fn-only carve-out EXCLUDES dart (:226-235) — + bare fn-ref names may resolve to METHODS (implicit-self) — walker just + supplies names. +- rnCrossPlatformEdges / expo / fabric: dart NOT in their language sets. + +## Parity mechanics (all have bitten before) + +- **Emission order** per §Misc + §double-walk: file → source-order walk + (per construct: node + contains → for classes: extends/implements → + decorates → members; per function/method: node + contains → type-refs → + decorates → body refs → then the sibling-revisit twins) → function_ref + refs (in-scope then twins) → value-ref EDGES last. +- **generateNodeId inputs**: (filePath, kind, name, startRow+1). Names: + operators are ``; ctors are the ctor NAME (`named`, `_`, + `create`); anonymous extensions are the ON-type text; imports are the + URI; enum members the constant name at the enum_constant's line. + **Duplicate local-fn nodes share an id — emit both rows.** +- **UTF-16 columns/slices** everywhere; non-ASCII lives ONLY in + comments/strings (identifiers are ASCII by spec — a non-ASCII identifier + ERRORS and defers). The torture fixture's unicode comment + string pin + the column math. +- **CRLF**: fixture variants derived in-memory (kernel-tsjs-parity + pattern); expected: byte-identical output modulo the source bytes + themselves. +- **Defer policy**: has_error → defer, `--max-deferral 0.3`, expected + counts shelf 10/99, bloc 21/616, flutter ~1340/6465 (flutter HEAD drifts + — re-sweep at port time; the RATE is the signal). +- **node_ids self-check**: compare ID STRINGS; do NOT dedupe (double-walk). + +## Gates (per plan §5, adapted to the byte-copy vendor) + +- **Vendor gate (replaces the usual bump gate):** wasm byte-copy + + `VENDORED_WASM_LANGS += 'dart'` + kernel C vendor + langs.rs + + `GRAMMAR_LANGUAGES += 'dart'` — full suite green; one smoke dump-diff + (old resolution path vs vendored path) on shelf, expected byte-identical + (same bytes); kernel-grammar-parity proves C-build ↔ wasm table identity. +- **Torture fixtures** per `## Fixtures to build`, exercised by a new + `__tests__/kernel-dart-parity.test.ts` (+ CRLF variants in-memory). +- **Parity sweeps** (`scripts/kernel-parity.mjs `, order-sensitive + full-object, **`--max-deferral 0.3`**): + - `svy-dart/gate-repos/shelf` (small, 99 files — server dart; re-clone + dart-lang/shelf if gone) + - `…/bloc` (medium, 616 files — Flutter widgets + pure-dart packages + + generated-file population) + - `…/flutter` (large, 6,465 files — the framework; the deferral-heavy + arm) + (all three cloned fresh at survey; re-clone public OSS — agent-eval + policy). Expect 0-diff on every non-deferred file and ~the §Grammar-prep + deferral counts. Then **full-init dump-diffs byte-identical** (kernel arm + vs `CODEGRAPH_KERNEL=0`, `scripts/dump-graph.mjs`, cmp) on the same + three. +- **Census spot-check** (double-walk belt-and-suspenders): after a bloc + kernel-arm index, `select kind, count(*) from nodes where language='dart' + group by kind` must equal the wasm arm EXACTLY — the duplicate-node rows + are where a "helpful" dedupe would silently diverge before the dump gate + runs. +- **Suite**: torture + CRLF + a defer fixture (empty-object-pattern file — + kernel defers, wasm output served) + the `library;` defer shape; full + suite ×2 green with `CODEGRAPH_KERNEL_EXPECT=1`. +- **`DEFAULT_ROUTED += 'dart'`** (kernel/index.ts:37) only after ALL of the + above; changelog rides the existing kernel entry. +- Post-route perf sanity: all three gate repos ride the raw path (§arch-2); + a mixed Vue+dart repo is the decoded-path smoke check. The dart speedup + lands on ~79–97% of files (deferral costs). + +## Fixtures to build + +1. `__tests__/fixtures/kernel-parity/torture.dart` — seed from the survey's + `svy-dart/torture.dart` (231 lines, parses clean; its + `extract-torture.txt` is the expected-output pin). Inventory by branch: + imports (dart:, package: with `as`+`show`, export with `hide`, + **deferred → invisible**, part → invisible); doc shapes (`///` run, + `/** */` kept, `//` kept, annotation-broken chain); annotations (bare, + with-args, stacked → reverse order, on class); top-level constants + (CAPS/lowercase/multi/typed/derived, sig truncation ≥100 chars); + top-level var/typed-var/getter/setter (all invisible); async vs + async*/sync* (isAsync true/false/false); returnType matrix (builtin, + generic container, nullable, prefixed → `other` bug, `T` leak, void); + signature matrix (params verbatim incl. named/optional/defaults/ + function-typed, getter type-only, setter params-only, generic-return + `Future ()`); external fn (position after keyword); the full ctor set + (unnamed skipped; named bodied — no sig; named bodiless — `()` sig + + initializer-call invisibility; factory; **const factory + const ctor + invisible**); operator → `` method; private `_` names → + visibility; class with extends+with+implements (ref kinds/order) + + with-only class; mixin `on` (nothing) + mixin implements; named + + **anonymous extension (class named after the ON type)**; abstract class + (bodiless members → kind `function`; abstract getter invisible); + sealed/base modifiers (plain classes); enum (simple + enhanced: ctor'd + constants at constant positions, args unwalked, `with` GAP vs + `implements` ✓, members after `;`); typedef ×3 (modern/legacy/generic — + zero refs); extension type (container invisible, **members leak as bare + `function`s**); the FULL call matrix (§Calls rows verbatim — incl. + cascade invisibility, `?.`, const-object args, chain re-encodes, + interpolation calls, `$x` vs `${x}`); static reads (`X.member`, + `X.method()` double-emission, 3-segment nothing, case-pattern GAP); + local shapes (locals/uninit/lambdas/local fns — pinning the + §double-walk interleave exactly); fn-refs (positional arg, **named-arg + NOT captured**, rhs + param-storage-skip + shadow false positive, list, + pair, top-level/static bare-identifier varinit, local alias not + captured, undefined-name gated, file/class twins); value refs (targets + CAPS + kName; readers via sibling pull; constant→constant; `${X}` read + + `$X` non-read; `X.member` member-half read; local shadow prune; + uninitialized-local prune; assignment non-prune; lowercase non-target); + a unicode comment + string before a symbol (UTF-16 columns). +2. **CRLF variants** derived in-memory (kernel-tsjs-parity pattern). +3. **Defer fixture #1**: `switch (x) { Init() => 1, _ => 0 }` (empty object + pattern) — kernel defers (`defer:`), wasm serves the recovery output. +4. **Defer fixture #2**: `library;` header file — same contract. +5. **Generated-file fixture** (`x.g.dart` naming) — extraction normal but + NO function_refs / value-refs (the isGeneratedFile skips). + +## Probe artifacts (session scratchpad `svy-dart/`) + +`cst-dump.cjs` (full CST + field labels via fieldNameForChild) + +`mini-cst.txt`/`probe2-cst.txt`/`probe3-cst.txt`/`probe4-cst.txt`/ +`torture-cst.txt`; `extract-probe.cjs` (the REAL dist extractor — +nodes/edges/refs dumps) + `extract-mini.txt` (imports/deferred-import, +ctor set, operator ``, enum shapes, mixin/extension, call +matrix), `extract-probe2.txt` (THE double-walk interleave pins, local fns, +async*/sync*, annotations, value-ref prune, top-level shapes), +`extract-probe3.txt` (signatures verbatim, num/dynamic/Object refs, +external position, redirecting/const factories, lambdas, decorates order), +`extract-probe4.txt` (block dartdoc, extension-type leak, record-misparse +rescue, this/super calls, case-pattern gap), `extract-probe5.txt` +(value-ref matrix, prefixed calls, docstring drops, unicode), +`extract-torture.txt` + `extract-crlf.txt` (the master ground truth, LF + +CRLF byte-equal); fixtures `mini.dart`, `probe2-5.dart`, `namedarg.dart`, +`fnref2.dart`, `fnref3.dart`, `torture.dart` (+ `torture-crlf.dart`); +`probe-dart3.cjs` + `dart3-errors.txt` (46-construct error battery); +`error-sweep.cjs` + `errors-{shelf,bloc,flutter}.txt` + +`flutter-err-files.txt` (incidence + per-file lists); `error-diag.cjs` +(first-error context — the class minimizations); `tree-sitter-dart/` (the +d4d8f3e commit clone — vendor-file shas recorded in §Grammar prep). +Scratch dirs are throwaway — re-derive from this doc if gone. diff --git a/docs/design/rust-kernel-migration-plan.md b/docs/design/rust-kernel-migration-plan.md index 9a437e6..a255dda 100644 --- a/docs/design/rust-kernel-migration-plan.md +++ b/docs/design/rust-kernel-migration-plan.md @@ -611,7 +611,7 @@ parity before porting the language. | r | `languages/r.ts` | T1 | crates.io | **DONE (R7b batch 4 #1, 2026-07-20)** — `rlang.rs` walker; NO grammar change (crate pin `=1.2.0`: the crates.io tarball ships parser.c AND scanner.c sha-identical to the r-lib v1.2.0 tag the vendored wasm was built from — first true no-op grammar prep). The lightest-shared-surface, heaviest-hook port: r.ts works entirely through visitNode (every type list empty but `callTypes`), four shared machineries dead by language gates, walker = file node + hook transcription + generic extractCall. Parity 0-diff on AnomalyDetection/dplyr/ggplot2/shiny (838 files, deferrals 0/0/0/1 — the 1 = a moustache-template pseudo-R file, both-arm) + dump byte-identical ×3 (dplyr/ggplot2/shiny). kernel-parity.mjs gained lowercased-extension matching (`.R` is the dominant casing). Quirk list: docs/design/r-kernel-port-checklist.md. | ☑ | | lua, luau | `languages/lua.ts` + `luau.ts` (36-line extension) | T1 | lua: **vendored C** (v0.4.1 not on crates.io); luau: crates.io `=1.2.0` (tag≡crate sha-verified) | **DONE (R7b batch 4 #2, 2026-07-20)** — ONE walker (`lua.rs`, ccpp-style dialect flag); lua = the second vendored-grammar-C language (v0.4.1 tag artifacts, shas in the checklist); luau = plain crate pin. NO wasm change for either — grammar-parity rows replace the bump gate. Ports the require/visitNode-hook asymmetries (top-level imports vs body `calls "require"`), receiver-QN methods, the top-level initializer-visibility inversion, raw-text callee world (colon/bracket/glue chains, paren-conversion), LUA_SPEC fn-ref capture, LuaDoc `- `-keeping docstrings, and the lua↔luau isExported wire divergence. Parity 0-diff kong/lazy.nvim/lua-resty-core/lune/Fusion (1,734 clean files; deferrals 1/0/0/3/8 — every one matching the survey's both-arm predictions) + dump byte-identical ×4 (kong 157,650 dump lines). Quirk list: docs/design/lua-luau-kernel-port-checklist.md. | ☑ | | scala | `languages/scala.ts` | T1 | **vendored C** (master@0aca5d0a6f — not a release; crate 0.26.0 is 30 states behind) | **DONE (R7b batch 4 #3, 2026-07-20)** — `scala.rs` walker; the third vendored-grammar-C language (35MB parser.c — the biggest grammar in the tree). NO wasm change (production has parsed with this exact revision since #91) — the grammar-parity row is the whole alignment proof. Ports the leak-through asymmetries (extension first-def call leak + braced-form invisibility via the `{`-token body field, anon `new T {…}` template_body member leaks, bodied-vs-bodiless class_parameters), first-segment import names, the val/var hook's enclosing-NODE-TYPE kinds, defs-as-methods with top-level function fallback, nested-def invisibility, curried/type-params-first signatures, the #750 capitalized re-encode, static-member WRITES, scaladoc retention, full value-refs (last-wins targets) + SCALA_SPEC fn-refs (varinit + postfix eta). Parity 0-diff os-lib/cats/scala3-compiler-src/scala3-library-src (1,935 clean files; deferrals 0/15/57/116 — every count matching the survey exactly; scala-3 PHANTOM hasError deferred on the flag) + dump byte-identical ×3 (scala3 whole-repo 950,889 dump lines). Quirk list: docs/design/scala-kernel-port-checklist.md. | ☑ | -| dart | `languages/dart.ts` | T1 | **vendored C** (UserNobody14 d4d8f3e — reached via tree-sitter-wasms' unpinned github dep) | Long-tail T1, survey COMPLETE 2026-07-20 (docs/design/dart-kernel-port-checklist.md). Port = vendored-C + byte-copy the tree-sitter-wasms wasm artifact into src/extraction/wasm/ (kills the unpinned-dep hazard). The sibling-body DOUBLE-WALK (duplicate ids, ×3 refs) is the port hazard; sweeps --max-deferral 0.3. | ☐ | +| dart | `languages/dart.ts` | T1 | **vendored C** (UserNobody14 d4d8f3e; wasm = the byte-copied tree-sitter-wasms 0.1.13 artifact, same commit) | **DONE (R7b batch 4 #4, 2026-07-20 — the FINAL R7b language)** — `dart.rs` walker; the fourth vendored-grammar-C language. The wasm byte-copy into src/extraction/wasm/ + VENDORED_WASM_LANGS kills tree-sitter-wasms' UNPINNED github-dep hazard (crates.io dart is a different-lineage fork — rejected). Ports THE SIBLING-BODY DOUBLE-WALK bug-for-bug (duplicate local-fn nodes sharing an id under different parents, duplicated calls/instantiates, file/class fn-ref twins — pinned by a dedicated fixture + the bloc kind-census spot-check), the extractBareCall selector matrix (first callTypes=[] language; cascades invisible, `?.`≡`.`, the `ConfigT.load()` calls+references double emission, capitalized-chain re-encode), the constructor naming/skip hooks (unnamed ctor skipped; named ctors renamed with class-as-returnType), operator methods as ``, static_final_declaration constants via the hook (instance fields mint nothing), prefixed-return-type prefix bug, enum-with silence, anonymous extensions named after the ON type, deferred-import invisibility, named-arg fn-ref non-capture, async*/sync*≠async, value-refs with the LIVE sibling-body pull. Parity 0-diff shelf/bloc/flutter (5,815 clean files; deferrals 10/21/1341 ≈ the survey's 10/21/~1340 — both-arm empty-object-pattern + `library;` reality, --max-deferral 0.3) + dump byte-identical ×3 (flutter 6,472 dart files) + bloc census identical per kind. Quirk list: docs/design/dart-kernel-port-checklist.md. | ☑ | | kotlin | `languages/kotlin.ts` | T1½ | **vendored C** (crate unusable) | **DONE (R7b #6, 2026-07-20)** — `kotlin.rs` walker; the arc's FIRST vendored-grammar-C language: fwcd 0.3.8's sha-matched parser.c/scanner.c compile inside codegraph-kernel via build.rs + cc (the crates.io crate pins tree-sitter <0.23; tree-sitter-kotlin-ng is a different grammar). Behavior-neutral wasm re-vendor (dumps byte-identical old-vs-new ×3). Two walker firsts: extension-fn receiver QNs + owner-contains, and extractModifiers→decorators (KMP expect/actual — 412 synthesized edges identical both arms on kotlinx.coroutines). Parity 0-diff okio/okhttp/kotlinx.coroutines (1,861 clean files; deferral 4.7–8.5% both-arm incl. PHANTOM hasError files). Quirk list: docs/design/kotlin-kernel-port-checklist.md. | ☑ | | swift | shared + dedicated branch | T1½ | crates.io | **DONE (R7b #5, 2026-07-20)** — `swift.rs` walker incl. the #1020 dedicated property branch (Alamofire's 348 property nodes reproduced exactly on the kernel arm); grammar bumped to crate 0.7.3 (wasm built from the CRATE TARBALL's src — the tag ships an older ABI-14 generation; delta = error-set membership + 2 gate-found categories, all classified). Parity 0-diff Alamofire/vapor/swift-nio (720 clean files; deferral 9–27% both-arm structural — sweeps use --max-deferral 0.3). One walker fix found by the sweep: the shared `assignment` shadow-prune case is swift-live (declared-then-assigned `let X: T`). Quirk list: docs/design/swift-kernel-port-checklist.md. | ☑ | | c, cpp | `languages/c-cpp.ts` | **T2** | crates.io | **DONE (R7a, 2026-07-17)** — `ccpp/` walker; ALL pre-passes stayed TS-side via the route-point preParse hoist (+6 new blanks added during gating — see the checklist doc); content-based `.h` C-vs-C++ detection stays upstream at detectLanguage. Parity 0-diff + dump byte-identical on redis/git/fmt/protobuf/ALS. | ☑ | diff --git a/scripts/kernel-parity.mjs b/scripts/kernel-parity.mjs index 64d5cc9..db7cfa0 100644 --- a/scripts/kernel-parity.mjs +++ b/scripts/kernel-parity.mjs @@ -48,7 +48,7 @@ if (paths.length === 0) { process.exit(2); } -const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau', 'scala']); +const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift', 'kotlin', 'r', 'lua', 'luau', 'scala', 'dart']); const EXTS = new Map([ ['.ts', 'typescript'], ['.mts', 'typescript'], ['.cts', 'typescript'], ['.tsx', 'tsx'], ['.js', 'javascript'], ['.mjs', 'javascript'], @@ -67,6 +67,7 @@ const EXTS = new Map([ ['.r', 'r'], // R7b batch 4 — real-world casing is `.R`; extname lowercased below ['.lua', 'lua'], ['.luau', 'luau'], // R7b batch 4 ['.scala', 'scala'], ['.sc', 'scala'], // R7b batch 4 + ['.dart', 'dart'], // R7b batch 4 ]); /** Collect candidate files. */ diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts index 5d105c9..d412763 100644 --- a/src/extraction/grammars.ts +++ b/src/extraction/grammars.ts @@ -330,6 +330,14 @@ const VENDORED_WASM_LANGS: ReadonlySet = new Set([ // tree-sitter-kotlin-ng is a different grammar — the kernel compiles the // same vendored C sources instead (codegraph-kernel/grammars/kotlin). 'kotlin', + // R7b batch 4 (Dart kernel port prep): the byte-copied tree-sitter-wasms + // 0.1.13 artifact (sha256 7f5364e4…, built from UserNobody14/ + // tree-sitter-dart master@d4d8f3e337d8). tree-sitter-wasms' dart dep is an + // UNPINNED github ref, so a routine tree-sitter-wasms update would have + // silently changed dart's grammar — vendoring kills that hazard. The + // kernel compiles the same-commit vendored C (codegraph-kernel/grammars/ + // dart); crates.io tree-sitter-dart is a different-lineage fork (rejected). + 'dart', ]); /** Absolute path of a language's grammar WASM (vendored or tree-sitter-wasms). */ diff --git a/src/extraction/kernel/index.ts b/src/extraction/kernel/index.ts index 09a117e..c4337a0 100644 --- a/src/extraction/kernel/index.ts +++ b/src/extraction/kernel/index.ts @@ -103,6 +103,13 @@ const DEFAULT_ROUTED: ReadonlySet = new Set([ // scala3-style repos use --max-deferral 0.3 (swift precedent); a // deferral JUMP on cats/os-lib-style code is the bug signal. 'scala', + // R7b batch 4 (2026-07-20): parity swept 0-diff on shelf/bloc/flutter + + // full-init dump-diffs byte-identical. Error incidence 3.4-20.7% both-arm + // grammar reality (empty object patterns — the sealed-class idiom — and + // unnamed `library;` dominate; flutter sits at ~21%) — sweeps use + // --max-deferral 0.3; the RATE, not the count, is the signal (flutter + // HEAD drifts). + 'dart', ]); /** diff --git a/src/extraction/wasm/tree-sitter-dart.wasm b/src/extraction/wasm/tree-sitter-dart.wasm new file mode 100755 index 0000000000000000000000000000000000000000..17007b4fd9bdc1aedc77c699601efd1d2c84f520 GIT binary patch literal 984666 zcmeEP3xHKq_uu=>+-Yjgt)!CaVe(9-BFVE)2Q_)W-;abolB9?Cqp2pQOqtRPVNgV+ z5JCv05K19LQ%$M#m=r?l|66+Za%+s)m#4?8Z^5<(uDezoi;uD1F?$bPaPeS;L@YJrcGeuR^h{jA@u8Yx|G zzAe35pWFM~(&gH&!lKJ?=gvL4_UPIB&d%3#>C-i(pCHig+_`U;Yi{c5V(B?&U(oWu zx88hhv%bB%cJ17!Ti?E2dw0IBOYgp&yWWAXH+Q+IbDwLw+@ATevaPVD}r1zG?61b&n?`~ag>ULKY!4|>yfuQG3(oq_#%@VcfYTwSC zyWM=ufUykB zFu*tl<{O}hfwv4Wo`DDcbd@}jfdK}X%)sX_xtW{Bz+|J-=?uI)!3{Bkfr%!SnG8%b zA!ae~vjJu^@PN_jJO*Afam;66x&an2Fn+sBeK7++nMju~u-pJk8Ti2f#SD}fpoD?% z46ufQbp}|^z_$h{W#B6VY-Qkc18ig9GXrdA;70@G?o{>T0|VqSFv|e>418>W0tQ|) zKp_LK8(<^@-#*}$%UA|Bnh@g{c*g)m418^X@eC|5z(fWHMd}9wQ%s0y47_IwYB~cO zOo$l_ylH@$47_20Sq#h{>{6f2z{@7mc?>*efcXr3V1NY-j5fex9Y?+!=@JIUn-EJG z_|k+ZX5b4GqJ)85ll?UeY#881x}JfL2f08g0|QMlY-QkC6X`YvCKzBl14RbN%{`9# zvBwRN$3UskSUv+EjdPPNVBl>NqL6`=kGLU5GEi)&k7Zz#=^V!~Q1X;}OA!NanT~C| z4q-Zji42T2aZF}l?pQaDX$(v?DxA*10z-WU1D~1@GZ|QJLd;@d!V_+!vl;l=5Sz!q z8$;X>^BE{M*Xg} z1DlFmpp=0P16^P%1G9|AwlPp*ZrQHmxZk}cx4)_%FBk>oF)-Co&u8F60~9c@&_r6u zz;IJ?BN@myw~S@r1yc*hF)+yhMGP!7z<37o3^0*_#Riznz)Vxv(-?TcsBk(1e;R$v zU|@j(W->6t+%k)SIi_mQW?#?!kRl!)sM)8HIIR}%q{s0Y%v8@z`#NS6f*F(QP4;R zMi^i$1Dnh(;~4nV07VSEVQv}Ez%T<$WMIidu0AF+P-L3eGzO-dCN`acXU*Jl1_L_` zFq46|O^cevz!cM7W;5`j(Z@UnJ~qI729}uivVegHO~qZzz;x3*mN1ZKm@Z`?cZ{34 zVg^1N=>jDTd}Hd^8V2T@5bGHjJIcMKlz~6YEn68_Xj0k6zyLGwZD-(dGY`tmQ}yFT zLp_gyNu%9V@)?+AfC2{IH9#Q)iwrQ5ft`lwSO$JH#Kti&!ep+9fq~|h@eFJfWMD8F}KZY9Wc?>*jh~+a-Xn+C+hL|>2$iRz6$s-wf$+YaT43wBu#xd}g z2~osAsR=Qjfn_Fh6B!s(;8xtp3@k9oPGexU8P=vVFv?W^84N6b*o|W*10|-TpT)qN zW)Ppvz-H4s%wym^)8^(g@TCD3Fz~qn7BldHnUE}D;9&zSW#Bmj6f z2DTa%u4iDB2~ohCHj_kLABemBJO80c>_me0T@GZGds z@Uj648Q5rg{*eqkWs)7sz(|wqI0lBBR$0Wr!)CTMo`IPr(uoYrHo#;C9v$Z9Wf}v8 zCd70GJ~AO@Fz}?ANzY{9MFY%Y;2Q(XX5f1h$2k+ZdQyk(M|#=ukqOlM$`X_Ye=SYblUWZ)YE%wk}t$^L8xo;2-cp1#F|n9smM zqxA(0tSoX1YB2-fnK+g(u+acZ8F=2@Qp~_BrjC^`P+*o`YZ%yM%4IzRe;FR73=B7Q zY%2pV7+@O%pBZ2~0}mS>xkFU_m}dIqJO<{N5cv%JZrV!$17poCg$xWdJU-Q<}lRi)H|x$-rzAVip7IO|r9f2-7^~F%Yp^&SxNEw_L!$29uY?42(DB zvV?(%-Et`dADLT<8Q5VIRKmbxrVC!fz&2BI>lr9EtF=-F9x=&oWnjBmByMA1oGF*> z49qh?Zh@*FLky6|K*VmD&p^a(S-?P%>FEj?_|!}UMlvui*R3#P8Q5%EfJOfN*V5?EkWCq?eaZF?2wMlLq(-|l*zzhb4z2t_N$-sBhTwoRhFPmFt zGmvk9c?=9Oam;7nYZJ!;1|}F{iy3(NIX9Ih4D>f4mNGE#c{fBc10PIrff5G3e$fTi zFtFT&SkJ(C1C%oGtGQ(>0}q-I+ZcGngxJo&s|Ls&s_MrgLp_gyEt6dy`3$^c3aUWg zV)9bRz!H<&kqqoKJjOEckco60178`Sh=D&$F^p$mk_j=9fp-lsnSq5S*=Y>yG{AHQ zCK#qO7nFO|pUuE(6X`q#elZ%G&p?p@7BDcMXJDt{QNY0GCPX0vFBiDE9nZkirW>Egz>{W3n#@3CYjGL_3k%&i zrZZ4v`t=zMyl>)|$-o-Z1I zFtE-{dY3Y=#Y9@nz*;jzmoV^+$;%oBB1@k23`90kOBsl)qqZ{exzXu124*t=4=}jg zr3i8b(_h|AktzMG_E}a7A;W?`1b?LPhlLN>%o4RlYWtM-S<;bonZB2F;jqZaP$8UF z9aH-`qA7l;osJmkE~j}8-CsLhUF{!gYB{oLN=kc5&}mNLWk`K*m6HmnLpWqh#D?%l zPQ{ht$nN{6gj0}mniI+j;jV_q%Tz>@YKJm7Ih~M|g}^s9O#zz0ESOkR%N7|TBP%t8 zA8KV-Zg!C(vV+JdP0F|eLNARjx8>3jByaE|iSwo^%AS7Cqi6Jr=E8D8E2k#_BrRCcm4$zUUcy#mtJ=H6<1!>`RXp$Tzg&D z|6YGXw;Q|nxcL=py4CZRUcLMDebu`4w%hNx^RBz^x%a+)xw5|;AP34kIY>Sz3*=Ba zOb(YLGEg)-%?4Yl8Kx^_(@)dfs}$nq*C}UbLoK)2x@Qm#wW9cj48-zgg&FQykfM|5WOL zR~~!gjjbfc(~ha_^>tRNWA!EwJ@+5z(o>w-;?$<8__Q!+Wu;;u#h{qg5u$o`Cv z@UIvYoFlqB)lUuoLSNq#-JShT4R5ua2QA!zArRmSfcu^r-e%cbKxP~Idu|x`se1RC zA^C?TrR1n-1fhWge<6DtjWZat!w1-#aU&o{N9s1LEURYCU#t}UUra zz4HqXHzE5srI?WO8wL2)qER#CDrZ(nv~uX$qZ|hj)BU*N7}5`T-Pkk~Pd^(i3X5E@ zj(#Q`9Z33Po%F`HWujy6@a8Cmkrp#aqjss{g|U?LH*CF z;j|?tHHb+KWpOxVp zPE0b038s5!P^wy2^Dx;QVe&IESsRbZ8V{47EPIV&V!KRA%P^s9FO#3a#O7*Z6B9ea zB;CWLG{R&vFn!_6#U$)9S+F)*Cv@#)f_9x1c3P57!o(yTVN%`0WK)Dm zDKYsm9+TA`CTlHwwPI4!WioADG!we^GC@nrs>w`h5|f${CN(@vHb$6iA||WjFB*$wp$bDjt&(50f7)yF@Xm z?J_AX!-THAOg4f^ZDvxNnADCiu{})IN0@9NCMEHhtn@HhZP_aolf7If3)V;Lgs#0z zHh{@qTx0hlCVNGgggs1tiZEGEOjgEYvckh;m1VC`OzOByrfrC3Lf2j<>%pWB*ONNL zq)voMO%IcG5hm!=gjf-e$#M^q63bq$nC$H`Dcl&%gs#0zegc!dxpej>CVNMi)bcP{ z8)1S@O^D_3m=t@MthDT6L~S`ubHXbuXDf}5+`-g!sg;(YM%P|y=oz!>I$2bO>k_rP zhML>qV(naq45N~Afz)%;nzbof4Rq~I3)HgeIZY_7dX!c@l~!~*YC3_g ziPEC)k@Qd%S?%@R^m0q1)1zx|dWa^gJ`Zj6DZTn8Z_eHxwXce(9esol-^Ww?Qjgk~ zS@u#@0rqj3l$K#a*Ip**;j;E|8d1*oAtw7oA^*n>dM}0{x&8+1E{^v`iv&?M(#zQr5n#(|swCeIq)p@6qXs zh)&V6h4?m}PQUT!bg5;3qnKp6Op1Sw&MsYhnV?_F%H)nFlbB>inC#|d4P6SewnS5)YcB=V|Ez{wtPP1m!w7{29ty<~3d@PY5<>y$ z>*;0qYmYL%wd}7IlSVF++^x|}=-SH!EhDRu(~Qc#5ix1xmc4fgu$YqI>FpQvRZVZz zbaJ83bP_fFTScU?OQg6A5xVvgq5h~bcXf@4NaKh~GCeB!A)=CHq>``VspLzKN|spm zmx@Ufm&vSOqE$lIUM6TgSxvb6Z$eC(M3^-6F!?^h_<%Yi!f>AVX`#B1YM92i{mj_&7Bm_cP>rR0nz*<4oxH)OY<95X3ozP3);9dfJRC*F~p?+@IuR;i=Pz< zwYNRY#{F5&{?u7zQG3XWw1J~G{vfof#v18HR8BO|p*UC`42DFKxp^sINb};i(IiW6~)(oSt$fq-! zbp94ck`tbVW=Ft>ZY#qL-ZnP7Y#YPxS;~6T0(YUh<60&B7{$-mNKiPfI8vu2KIgcp zNk;{n5xH#)-9|;KdXNG1r2`5`-S(P-56cO^WjTw8Bxw~t<%Hj~oW%spa)CE2=SKpd z3<^P-I0BciAio<>d|BM>9Nyijad!9(%YH`%1JBnj=L@>;Z5MdWauyN*O+}iG+rXv$ zf(rMYpw1GC=oo&13I`EM?iDzmKZV*uLN7x<^w$YEe^N!_s>W@{SYCREpX26ZKkE{i zZaH%({F@4BmlJ-)awbzuD1Y@u=c!%yn$`^KO5_wo5bPz(8AHKdcY$e^GmZe(CPGZL zoKXb4>V|mHavmmNx(iIPoRI`5_2G*rsh6#br?|l;S?Id?!E&A;V44d&Z#j<; zFcq91)e$MR66>j!fI6KIDVHz0cR&wM(j6v|XDw$e0h8SjO`ON*dXl>SPfob8^AlZj z$>6$?^8v;9y!!onlt4pgBL$eK04N@H<6{aj4vGJSFFJQzIi9xc=R5&Fp@5GeU`#D~ z%F<=UG0vxek0Rj4vN0A}_5>BN zMg5ck_I5raphy9m5TcIrIRQ^9U<-h~obM@)Ck#;A`IQ zZ^hzUK!vLAxt2(K0%8ns=J zyRFRVi)-(|mWNbQoc9B^3ks-L_(AUUv>M!ZtRB^|Mv(Y&12MwdaQH+ZJh}IBY zdl}^_Mr~+1;?HP(gwbEojJEqQ8f4i+5VLT|F(FHB<&!T0as!jnhY}_wdmVHsl)FOI z?=3rq*H9YJeR#EWzN33O_u5}#%Lx}Tn?7t;zwM_rc(9P_(E$8?x_b_cD_oS zd?Ct4{-YcDD*6H)QoJSbv4|Jb084dvLb*6ZVj>RAa1}VLrwi3Bh3OIz;hMX-@Op0U znx5|E`djw>ieD&-pYw?uYl+N^a9hFLXqbu0Wv*opiWkd#Hx^As^<7bS?vyq)R^g;a zrH>@BxSA!MCUyxX{?(hN+3%<_svZ@LGUyy)$Y3VCUD~MFP7T~J6E|ky^DT9w9d#qe z|CV(2vzH-Q7{T69!NO&OsT!{|+B>|2vQK486#^Hut4I`BLAs0hP1@U4R5i;+1$r~2 z)68Cq6l)>H*YH^zpReL`FMLkNXB~XLg3rD2`Lc>;@2F^0jzPj|&;Mx8ajP_YjuQW2 zT!~r;Z-fiISJ3)L6ySEx470{CUgD@#3sros| zDH%>K4eLLHiCWZd#uv4yEp;h<9EZ}RvXs_Jdt)3*P%~DPFG#E??a$)>-n=7vAS#ZW z@bl816DJVWIJc3at@YxujkE*B}mrWgukVhpoPV`REKayV5>IPq^JD_#KQVEv~pP(DK zP~4#3N%0kuRtth}+D}1|EuhG|GhjtXv+tt7Eu++_YT3Jys&fKr+1nCMLq0*@i4Hnb zir10GYe4l77#%&hoRAZ~9kXPu;+UV&0B*zm)IMM+NwfP>!mXk>A`*n^>%1=Qv5Hsp z&ngSAYhE-)sHXC|6d2l^S;P!uU`(X(?|My&mvGm6bQg`7hl9~A88D!v**z(a)=|W; z#HZ9chKH*Xp*37jtl_A=#Dqma`u%45o!Zrri1H>1c4SnP6kksGCRh`wwc+PBWq*db zusf`U)CgmK295|0?iemmgb>q>uz09;c@)ySf$lh}Y=j7P18fr%3O~1v`dMj-%oX^; zR$S_aCQ0!uvhV?E>4i9Vfdl%M|2pqW)dd`lq_3m6kB*9)vw9tD7^-792BEH@P{))F z1+&*R_8swm>KML_ELfKcxjQ~IO$<%?kkqd+Gh(1jG}ggAjNgl);bGs9_zK<8&T|G~$38P19L zIG1iYvFt5S-1YuHbtR%5!`Ip8pa}{@au!80i`=*)s|pU&4ZmUZN0>7x%zH6mFl{*l zrb)Czzn@Qsq0;V=fesq6oJzrFN5?|d7^%U{`)+*vj*0aZ_~hw`o_5m@5kvT?&{u3U zDhddF%k|VKIG*tJ@#pE7FwkHK^JSXdkz$-vhS+N2g+BcTT1TZSON=H`k2F$sl2ORmR9P+o7aCjONTqJ1{%j*Je0#DQhQY zIP>W9KNNgkyx{+VQ5sFq`G|s@kb$KiK9A3UT^OIoWsqei%|4cHUmJ5fs_?N6X5^P= zIO{0b(G+Y$OfWpvaJ2KYv@ebGv(_mpzzv|Utn@!q?}ZUDx*p)ttpzZD++ep=_Omp* zjap`;*+;5%PnzAD64@NhK_}9ZE#fMXN6DstI}+)Dh-<*>@ksj=wKB>HpX>~$A8+-E zNDXA}o*MZEW^{K_uy{g!>3~>HRCSScJ2H|nr@Nd6i9q#XE;OY^Dy$=lem>0(1?wq}%H!0? ztp%}r6nmv_RKKXGRAl>iubI|UUd0prZ8XupnX>6^w$ZU(VKvaX640sDehRQ;@m-H*u8v$ zm)eJv7uh8yvdt9PjpavniG6T+kzI_)HY#Shl-q9QM|QD&Pwf8G8vU3m_22`>D5Hrl+ z%42qp-K4z8&gRI%hnE}4*>+> z5$$NQrD|mOP)}rss;zt7)$1M&Hv3EMt0=OO(UBnrOxq5@2c~Ncv#fA!J2QSTOmg;h z##tB=V`HJzohQ`pYRB+#pyduG7dg*Z7(9LMcv9bStmh7D06xKsbns(5!7sq00`@U< z$EfIx>HK?#x<{z^F?%)a>Z3|i&U3<9P9gnxiBCl34t4cWmzDld!$wdn7~a)Thg$hC zU8`wtEIlgx@abVptFo-V`%5QxtLTLyz#epZuMXi%p1Q`p&DHKXb_3-ikY?8=;-h0U zKuMr@8`Fq<7IDl8>xpjMux`9(+I4;7>kvKz5n&jv%d_G55rt3ZK#lCvDW)-g%=RT_ zr!h0jJ}rZ`kJIcLbkA77d-kDwI>BCm5!x?YhcHb@z%tB}+PIN*2&)WJpbq84bPC5* zkLE=J%h2eF1<%{P)od)4`Dv&Ft~ynQl=7=P57CdEd?G5hnx)y*O*MOpV!<*(RkQRA z=V`jmi61NKK!>oyc}T}}*`a9@X8cyuG~AGt7L^_9`cmz78P4Mt_0U5pUQ8^X!6*HK zSm4=|dS>`Inotvp2{kqGMj6g1%WkL{A@+wYdtXI2Cu~s+qsqo`BwDRPFt(>* z1oe)r#Cv0MC+#{U%cR=^(^`Hw=!gtwm9%SRI0K1As|;G11cnT1t?Nd$Vz;w3?rc*DIwIGko)McdYpKDOBw2iIIwA((jL`V zJv5wxVE9503}=#`N65j0y!ewAg8c8_|1?mZ2GG^0hhGb!}BOE7){ug!w!X$>MnAi1QQKE8HL2ttEpZ<_EmN~_c!U~r z@H3smfYBv%YPitKN<)wovKL?=A!nHs=NH(f3oYzuDSsFWz|{voZGn4KNR9-fk>s+A z-7bo21#aNGvF*i9H2dO{e4kSE$~e%?>5p5q(>fIKcZWWMDz13;c)CTHlS zQ(&X&UbC9Slg<1u1sOb4Wsuz4FcKq9?2Dhue6o`$Pa?k z9)y_>0Jt|`uOgE3YXpaz5H=tp!8ekk2I7Hi0Y43=4MLFn zDN)EFzqO+PuqV$d0R1heEdX+)iO%j;#F8oz3uW|Z8m$n;Dgr5L9r-aFIc()BPUkp| z3Kne3-U&-*inB%)@CoJ`u6C+Ws1oJEtjs^aLT%YQ)D3KhIni8GjewWjEL3{?FAS>h zQSEo@#2WCi{*nUpu`7iT6M$tEgp@69hG%obYdw?4y=VP6(uuoba!bOraL}J&+4#gdepw>lY~y z9T`b2<%hr}u~j>bRz}h$l>b*D>I(cHOP;WJSFkGtU{E@nT6cJv@x2 z5Yoe9Nltlqatwhn(~YQoGqsr?-vuofYb+{hc$$7VpRPXVt<^F z@AOT0wnCEe9FHL>gcSO@@+8CKVhW+&$1NkWToDh2&h&JC~?TlN>~PEx~MNe(u6&O#xib2#3?j&0cs6hdCdb0kIqAfKDN zW=ndwhMi})q&|@Jpo3+9s=|$+vcqt`#lwkp5 zktYv5gc7+&_4;#grU(5KNQ4$emOa}rdV^e8fPA2k4TuZAVpu3y_WKH4Xn{Z_6&T1!%xVD$AH$* zG)emkmU2KDhA$@fYF6;3d>j7+Meq=XBIh~osb7>%At8uT$23Jc!wHGRJy|*<2%*h? zu4a=YIrm%2+lJ$LL6UdBMNV-#=I13n5nw6zIAkbfzo>qqw*8!>2SzL#4gxyDXC*yg zVA<0YLW-Fn$;M*YQx!se>v&0i|CWx2$2M%Jy8s1w2G4>JGQ}kIw4?_WEPFDtj=~7p z lN&nc4hq=BXO-MN2zQqrRamhy(-iuVM0(Eyofcs(w$QU}8EP=Sq;ShWMeMm};w z1^<|Io+gBRSU8?XrSl9S@Op93&xgp_N&hrfI^*f5r|}c~yF<#&CI$VO@+q1?Kfyx^ zfoT{WC7ovp;oC`%9#;s386lnL34tdS!jN`{OXmeb$Xkbt zv`{*e2!Z#AMjld5Q*f&{cMX%y6bdsIRMC<`b>AXlkjmA$)C>P|p!F+~D zXDa;!pC}-tvBA=rMhM?deDbC95+U&CKp5&M9+1wHBQied(Z z8=~%{a_#55K>%$dbFtp%yh#AZO`5*fd5eGtaBnfCO0EtZ^loP+{W8eVxXXE)fIJ0I z+1}~ALjZYRaAxjs;7)`IBqBqr4cYh757celM$R~xH=0{-b>1TYo=z#~xXHukeY(Dn z%q$`JBIx^iJ8(3y?0eMX4I$c1WnJIm%qARLxSViLXAWJf`$+RQJ0H?D97i}WJ)F68 zeR~EC>><0i8&7v<9^u%C<#=v%KB8-Ep{8KO&IxyOKBntF8PvmsXb&<4qe>38{68VQ zSB8@YSo!j-jyo%%Msbrfp91$(W}gtY<7g@uqMbA*ca8HY{eBbdYJ^`;INf)(^BLjT zzT-@Hc0Q+Tbss79DrW&*V-t;=$d&ZWmWBIiavQ>S42_{7yGsU5%R;mRk10n8J0A}E z+YoJ9a1*_l9{#crPN#DbJ!WQ+(+th3a>5tVQ)U+Jn6Q#AaK5B#bw4$Q^PR8g`bzq} zM9sp!HrLd6&U2Q~^%e9xRhx62Z|EA{G92GI&bM@ZS%y;$w3L_1inz*TGT%{P>?hC~ zD<^!Wvy`r}6TnJ1gP!`a?2G7{rU9or*w3>lR-O}|=3qSvca-8La!vTil?dYta>vP=uIyfuo`fR$UmUfC$Lf7hk%H+u~qT>2Y`ke~%Bxf~U z!_S3lmP1eKSuo<$NEISmI`=&%!ng|jR9X**$S}@y+QGsKI46T<^dbAC44SovY=?fQ zj#fR1+76Rz%~I@H$LK-cZ*cPh)H=qWLad;~b% zHgLYcHEhwC7KO-5gFD35^u(40Zw_2j=XZp&nXa*g#SQ*&cw^ui8&oOkd8t7WgZ_Ln%F7Uaudk;NKQq7d1lF<}nbN4W7dC*KCLckB2LC0n&cE*Y3+h3uAu zlO7JC1Gg-`kBa|bdXUVr52xR$;T}W}+gfDR#$qQ#J_C7_-k}*Z%?Z&SJyv8PY_B6c zEupgLxhxCea81R!pM!l<3*m81`fB3*Mc2*fn$m0R?4WCPKZS4P?4)b#uw%6rqFphr z4w+7_1ss-f%;!VcW(7|C8#w(5-=D6jy6;0VHXQHRr9@^L4>ROs5;hm?x*Wa<(D3!JpxSXLS!e$)HbB;efS+SBlgGL2z5kLm@Y&X99Z~xPGBm9j4TNYeMUy!L&r&RfXKj`>}!e? zA;m}$f*dWXL5>yGA)mzArBW1$i$hXmiYp*nia+6~vQ~Dquyz-xLt656TZ%Lsi)RTs zT<@|_9nn}ECbC5<(HhShwh>2(w&G}Uj5t;tCyo~e+n>6$55@g=FN|+xSp!45TCA9b_WVZMVvW3_Q*;+{CA($W7uT#Q(iG1n+s@D4Ic*id&$`mMHh$_@pum zg)Ef*(V|pqxO*rSb%4viTWBv&`DdaA9II+abQ$kSTH36&)YGG-9{0pj zmU{h9OJ%gQMQiDHkCtvtNJ|F=^h=5NLieJ7Xz`Eef3|9E+#L#`H+6fUJ41EL^gxHj z?Sp8X*^~OAU$nLccyJRNR}Q z_`hB2ycz1=Jz}^Rfpu~7P#V^+ygH>-OY2b0a#peJM4M18tmyn!#V2D;T)zVOYpZhO z&E-s$%kuO0hR)w#ar2WNl^@D?aGv%mCr|Cws=X6l;8MPQ;T1PMIXMiT;p(>2-S>wQfJV+;#gB)E3gkPF-6v(BrtX=N{s>)C_2pEI66EpCQ`}=`1}! zUjn5_wxaJtwS^^8MGe@QYN3{}MIaM>PCK+d2ezIo#CM@)h%F@2V3$gVRmz6VXJ64s zoG4Bbr-?JgS>kMQjyPAGCoT{dE4$ET;u_Ii+$8#nTg7eS4z$;MMZS1Y3=u|?I=#O*{Yb$zq6{xduy{covunemP7MPv<3{ zVx_xZ1KDle4eY9Gc7Fu2+qN6n)zIvA1hU({8`x!NcKuU>T1CIqT|XzVH9IRUh@D8Q zdUiqUHD2@32!Od0WCz{rhc)Zqd3xA`A*%hWcUyipk7u3tt)XdTX^_iLk zeO3<`eQc}}FBP>k#~Ohg)6)*A&@8p`bJW_JTkSw@HItyfpwit-v#T4(uFh^?S4XpJ z5Xi3nZeX{!X4fc?UFL3JS68#k3S`$L3G9vwXt%XsmyuXUlJ#m|$ZKHBk>Xm+f~B}l zG==OA{{o5C;bD+>Vb&+HK5PYfFDz?#UIHs}Df(mAT8aVKxt3xe*0xgQVQ*TB`>`&S zA|Go{DTctdA+e(D09h#ZM}KjpI1sXnI2f|4Xa?CwG>5!hWJ3-UKcHWpF8_cWDmwtl zmFGd8ET4t!FB?jd$c#kmt%;VJXg&^>j(L4_o35yf|@U zdWyJKUMI)Mpw?Yq-+6do9cY<^IuOKeAI+{!AiLH{U>D?(5<612Mfqpy@w$QLUNz&j zcYm{?Ug5;|qY2XKzM9wZfjT`l2|5j8m#NvE7|5>OZeZ6?vpYGEowFO*HPY;I0@-!g z4eT0gcBcojJ9Rg(Yoghm9mwv?-N0@?&F=g_cIPI6UC<2sQuKP4iY(3X;y{iU?(!Kn z9_>_?hARWPU7iH}1@(FRYj#}%*>&Cx><-ZEx(2elb~ms)P_ye6$nN^x!0sT;u16rd z?z@5A!J1vKKz2QM1G_^syITX<_1O*VnrU`-rtPhLq|4j2BroaP(+()J>k;H9-Ok5T zI;cN6RCBvGP;+@yVZ*uN*$m$q6@_ea&2ymITyo}{0nwSI;~=_mhx`hiy&Jui8T*3XD2{S=m~pCBLi z#QU4Xy-+LP)A;$gAFDMmx=c?q68`>?o~EpS`<~d>9H%ukAgZq9mRnc$q`u~Ot)D(o z`sr1!euCC~C+IkzkFk~1!%m*-z1#`j%g_1PO0t#zatC-YNBb`a`-SXDW!FyYxqDRE zb*og_{YS?+CE@k@q$*pl?@48MqSkZIsIu!(ZrKH`3#Y1eVS63(O9AV`Y z?}^vb#Oq_i{v%$`k%!bAeZpufUF~4hrC<70Xay#1vyx}4LM9) z087bs`8MRm@(6g8{3RcNJW+amOmHX%PL*p2`JVPSxeDK3j`BCjf)~j=?RCQbCjEfi ztUXP}C{L5=kW=NikRQrrkR#F4I^;DX1G2lo(d{Vjy&&%pbs_H-`#|0!G9m93jUfjK znkD3m10V+r@=zTn4uyP3WJ4B;fA1{hR9)WND^%X6>GD3JTB5u7t*TW``wr@PPS?zi zN|@P^yNKBtn%S`lGdsG9nCJ0z}c{` zke5OmoP0;mqPu(in^PM^SqAB(j3e2as-I4e^+(uMb))>X+`oN}batG&5!6$iqwlGR z*UYZzL(kRBPE5F`YF9-))m{PZ$w5z&E>3~0E^;7i2zn|cL!1d|i*q1rit{0BiHjhq zJ+Xh!A{nnOZ7QcNZTJVbCBHTDrO0y~aWeXlfAbpo{5WlCSM^eUn!Q|U_TS!1UGNXo z?3Mp7G<)GcP_vztW;>ua_%~ZgFN&ktppo@reb2QCk6&G?X#5Idc8O+oeZtJT?jmNF zYGxJj;oLQ|k;^o*ig=9g8fKSkW)<t+*>Rh-WR#$6Qy#iSEsZv&n?V@(k+=6ydho=RX;+V9$fu7^;Iz5OT`~F^|*#-Ij zj!S^u(^bfhJ?gL3?1DV%t6FzK_3b*%>mhhL^Rp4<`SQCZGBmA;v77`w(?L%cmF;hW zSasE`?yL~2+mp=dznWG53bE>!WLDQ}R)Z?UYG9IC-Jn@bsSvA4m1GrkYUmx9<7bMy zAsdVPAX^IWsjh3VFYTV{dTTX0)pZ}y&1jcSEiLb~BN{6PrtPavhD)SP@F+o}Z%}Kv z(XDp@W5U2H9TS3Bb$2xr!0Lf2Wz{&q;>BJx>_5YPGJ{dh*mF`P|1e~>7zNo%`1!!_ zIV-Uztgx>OpQkbfHKkBafTzmE@>R%7Wfz!hHXUFMX&ddA0ZST(YOmz_cK z*`)5NqjXwukgYs+uEnPvdd~)F2Jhf|kbC!Z!ycO7Yw)n5lN%W zfZFp&mDZl1I^9#VdMtp|<5kM4>UynPH2+(xxhHcDN=vNYYJh&LYJ06-n#+>`x_qii zbs1E`y)~<60$5GhrL6jBR?h{ndVZI(>Z@5z3Sc#5m$JH5vzi*f>ZK}W71SHo#<|7m zq7GzrQ5Uj?s1KPT8bI126SAgg1X)WofvhcVS38%t>AY-7O^?~7Y?czco4GkP6aBXP z2DI|mpfn$$la6VI5wuVA3P!|q@fu`x@djiKF%vRFybEcI_aSSFIgqu)JV;{i?h|cF zkoktc$vmh%-=Q`5NkDD*v`TA35UV>itIq>iE!?H7?$WFl1+e;Zm$JHBv-&!K)i=A8 z)jgWkcLA)v-=(bX)vT5Uuv%WFtQrK&xmTf2s3+DyW{RI6v&BZpmSPKJd+{q|2k|>( zC-De+y=C$Y^ngO11sRf^A=Bg#$ZcXHXmDLLOg^ zmDL*Rc`UsTG7)>6`xeNc7Tiy#e^j-K*hP-4);M9iNX4xpxtdc&Z8gc{)L(O|sHLVd zoPtI(UK#P3#{7np?Wj`?^?8Zzny4+-Mr7}8n?@`BOff*`qIn-n zQ=~#>i!{iVq6TDpVMBHhH6c5RmS{&pwucPKM^&5hYe#f`5WW3mpw6A!j?&Y;?Py2R z+EJcP_lOF$qgF|6M}st{irVoiQ)h$9o_kMkzgZh4T~F){nXRl;9mKvdW&cbv{t~lz}B`z>}(Ci11?9L%n@`(4_n$QzG4kpXUFy%yn9u)$H>=Q+oq+co}(eo zIZsxf5j0K>HhQbbI5jY>GIcqK(-6(6qPE}4aH>ezvW2V>TGQn|W5RfUixk=@iLVC$aHU!d6q?fdfE!^*Q+H;;K2p1bQx`@Qb!F{r$UYChLjsE_Yj zsXjiaKjl%>JAUpD4b~F}LS~DDl{V=O)SbjQ)rTfBCmp8qS$0mktH#oYbo$3uNY6)C zO3y)kytmJcXL)vKS%sQ=^H7GiV0ho3Q*~`BsICszJmyqrU+ROT_Ln0xrxPnwuI(yS zu0eWwSabTbLVEf=sd^fzIbB;JJ#|T{owKGX%yv&07WUp<2`)6L+aL?@RlP4zJCy&wjEZZlS zo#T?-l=iz4vlF;hf*@V9=gC;jA;|OO=>&8=EYMQg}xaTH`raU5iO z(GIeMXb;&*Jm%5$MLsr}M|`w=Ow=l}dHUbA#suZ2qATN8$Wusi&SF=_?wa^fohx@u z+#xDAC;#o-1igFjROr2)I0G_M(AzY##d(k|#l?{A#buBk#FdbpgqQn|C>tT!Mz%&< z#U9gk_+@fXN{X_Nh2(`%xybq3xdR-Gy*=y%@+v1aMZhh>$f3N>;6JVi8 z{8U!&i7Zw1zMt|>V)gStIT5zZc~$&gpCYaOil4j6-i=S``-8k2t8%t+SU}mvo?cfA z=iQtlyzg1Q8olgc;u^?oaUEm}@n6W+;s(eg#f^|{#Ibmj@>0C}h~BMyKICk90puKc zE94@{BXQ?Eq)tK`*?%Vi(PVtFg%YWY0mO8Ek0i6kGLPsFQ`E95-LO=2nJ2GJI2 zm5P%ge~@QEZp7Q1`5o@P@kvjny64{Al+JHhep>7Nx76yMxedKfnPx9Ry*JMcymNw^ zk!n5B3o={uh3p`1hjeYtiH)ewlxf9PH9rXIE63|}A4;gN99ji^Wku{wwEIxs$I?W* z544XzLFZuiSrVVs4DL)whqqUO4uk4w`6CV2U9PV@-XvB>p9`p?e{ZA-%1im{9q$Z1 zk=fEjorkikp0e%j@8u;in~(R+p}foHwf{VC>a(pZsAbpH7*>dHT-uvN^N zbyKwNyyu=Y3#e@u{Y!jSr2lh+y}Bmo(j1^oDR83e1O^AU*a&NwNYe4mWsO}e~^Cq z$=CDusaj8WrKiDXsJ@_?JDocvXXYi%ZhETgdsfZkdv*%y z*2-%2RoVG@p1HN&J!L#7H_Uw;_|_9oLS~AmA+yB<$o66)WCt+`vXh{bl9ovutV5FX zu@}CJIJtRQ=b{dBLAly>x$%|<=Z5p~B63hqyrgn7UFF7GHt!`=Hm_89+3ZQ}Zo1Z9 zfp5FpleF=w)<(XsHiFtM_dnd{ysm2Z8<5%JEy$MQZO9JdUC2)2gM{1dYd-BZJ-uu% zw4;K((5@PPKR}Lm$M{RutKjkXb*E2 zJ$a%bY)ez4-nGK#PdoyAuKWhleZR_!=<&wOw;`XFb0F`M**KTtZh4;(C-yaRHad|&JNk+3Bmmruw)tEY%(!zq6~n{#Gs@-g#R^@-e4OK9XM^+>?0wkRMfB zS_hdeHb8a|rI4M}iQ&s+`St2UpL$jK{v@b8V%vvzCBXUPJSEaT<|Zv4L4J!{l=gpx z%oM*vW{d5REyYgA_QFE1(?NtFJBe7!>TqS9JW1Oi=NZ4n>8TOF#j@*}oC>z@%DpRX z2xcukMB=*($=+A+?kM=}C48joLOz~9qdf$7{zCTV%4uW3zfc<=Yi;CKxi;?q7i!}Z zt&O}m+6b~^q@xwr6Ez?+g$jG|LvP#k6aD00MEei(HLu#(v5)sefBmQ#IX`I-d%~vsY+6Nf63e~;@{lbuA+clR z$;sM;a`I`JoRobItYSH-Tze&d!+%@v^_kXRuQ)Zda@rX2FVx28S{sE`u8m>;LTxP2 z+9;@UZQTAZ)W$-sja%brqvE?cv3}5v&;uSOnyB6|3$lgSAF{PL5b{WIFk~CyU}d{V zoTRKbCqw=qPJx^)J3!8nBk^>~1~Ce9lVBT;1@DMeazDsonFYCAHicX*Z-x9s+y=Qq z-VV7^-T_%6*^lB7%q2GpdNQ|E^nr}s$N3F&NII3<^#E&Do&BM|&^pQprC^Mr=h7ndj1$?RV zeJ3n=v?@3(YF$8{w?VTep80v_d@Yd6dZHC%wrCC6L9~JFB$jz*O0TIk-kXr2IP<@+ zG^^M38gSRl|2QW+^W%9Q=fsd{8dCn zd3>vRJeL5E=ab0eJI!NK0z9T9k;hWaV`>6CUP>a5?=_G93Gf)0L>@nA9)l9#@jxYb z1lb$CeO_#DNAF#+p% z_;@As7{p_v=J8|#Jf2D-k4>7#GYRmRPzfFtw-)^~t%_cIqTeoRsn+TJ#&Vb!N>w&S zS|K(IXkm#wyLTyC+hO8z$ZT;XWD7yh7Pc1Txp<_w7836!S2oq7l}+^+WmD|~xk&Vd zT&iuVHY}y9y&<#3ZICU+fnars zJQ%W29tSx<{-PP)RXyGFq#y4lbdO?}_-XU^s5fu~vFoSU4N&X`DR%V~FXqVXe%0*q z$>WG~1e$X^|CEb@1;{2KCInfSZ7D(?~54StbNM)^f{ zgGc03Q67=MX-!9bAP)}Ekl!fqZ|V8B=^PhS_ns!?dRgq+`Z4SuUq612sUMjE^`jf? zYK=u9a#l}_fXoylA+yD3$d+O(B%V`->?G=)8ZPI3UwhJM|EF8?W5&5XNekPx z7H*Bv!rvY3|I#r&;WOHgiyE=Yf0tG4XrB?#-o~RXxpNSnee8e@AXk1WKa)@UFe<7P zql)h+d!LqxT@O5m9JKgHtO|DOlDreA;YWIt!_4{cRo(affjQ$^S)h77?g5WQ9~ad3 z37i~BrR(;6J^$DD!IP%^^`6u^%Zq9Cds5$LX)WaM(OO8+S}2Us!k%OcO4V8zW^6$P z9$QeweKfd_9}Np@_HMTMxSkqiJv2f($0MVj`y-zTclN(0m4BMn#_gv3Z}pV_-yP#) zy(wQ%qkFP_Dig7OR?|7Y8~M!Eo|AW?4TzkaZW&g*DTI~WPiQEmq>e))F$bP6n9r&-Il5p41X- zt%*KH6TS9OO@y^3x*JV&+e0-`Q){B9(L@iACibKiR4uKE9x-c&^Z+|eZGGp|YPPR$ z?@QI17@yum_lLaiB?{uOm*z0291agul0(qD{$9a+@Hlu|;4BPr04yIr%CoU%D8?J* z*{bmpPGdM$94}4~Q(>X^dO!2-)RgLU)^~Y(XD8#-)L1)O%YgE!+MS=>yXW&Pc7C3U z+WGOGg0Z*ObY#yb$nyC*$}C&F3E5H{gEC8#S3nlZx;mz}O*FTKar>-~lGH`Q@`>9f1HD5}0xbiXmE4u6Z<+g30ue*XDuJePcw zI9lwFH}lcH)G9e3PA=CaLnxH097O^;M^ zYznF;zanSudX-nITg(deP~GGGC^yGlt8V(6YtCXB zCqZw|{!@)IH>;Vz;ri|!amSb6D`_|V6s{sp_y1U;(Mu!8kO-<4`Pyv z*>Zt62YhDB*18{EF1y3?%4_p;=Z@V%jeO^hH23tMKMsXOH3d(AjT9ls(V`mUSe&f@ z-)PJ$r6>}-9^;kRkypE^^mhW{MDY&p?;pdwE-1kLelqrPN| zdXV>s8&ykctF^Lsjd+&6nn|s_`+!FWaT$0FlSgYF&7xL4ZFT8vN5AX0>M5&{Xsb2b zL4!)Dk>r-RT zZ7tt3Kd3)A3N`)*$^Fwox_>%Br+R=-@6_~f_fCoFwpRspdpz>sKKtOO+u2IDvpu?P zS4OuzE3DgOwq!mLo}YhehQ4W^-EbECM5G)2G$eE)4xKezn@R~m9=aJ zmH(AG{al~)?@Mz2uhQw~`J_LflIbV5W*CoI;x^G)a~YEse}x}CKdIQ7A*dX#)@kSa z=;8iK>LDooE;{`JpY(?$IsI#N`U`!$nm(%J?qN{=uhr=n`s9CDCG#IN7V_@Tb(+QA zJ}i>E^TYd4&!8<7%C3e<)$c$BmBoK`+9Q3mFrt!W5tRP*I{mRe>5oow`ZwtGclfl0 z%I>5G<-eOwf1FSLAFX8mgWAH=n48m1C_gn*(rn1Nqu}Jb&wrk)2qym zqj#U8qQ1hFKbtL)9g3T@b|X6!L3Of+zT*X-@|al3@(4=*W}W_vKIu z*-1|SR-OLGKIzY^Wcop4(t6B_8jIUBi_(<%D};?Hm9d)zJzqLOc~8y9=$NTb5A>cJ zc)PY`t(DJ&Lg1PWFP={Dhj;=uti3#bIt|M?GqAmRy7Urpsh~H|2Kf+wuEy%Spq*TK z59D-tFn0C(%R98DuCH!K*}TcZc#3A$wR!_Eqo*bkf4|S)<#VUz^F%p(#{CUGLB1Rd zm43XMxeMjwo?+*&o1(wLCFp$G#j55kfy@?5AzO+$D6vcAhmeJGC*%Nmx7O2Ln0vb3 zc-}JWZg?f~MyABh%`H~ERw`brJ-p_6c-^CU<@@lu_iykDYHynqmo1R4x8hoOi$;CWTt+Lc2Ii(~C71&YU*Qj z>Qj71pCF%&%8fo_b?PVhI4&Gkj7%EvczLu2Vn9C-t+En)(wu^$UDbKQF1NKdDoH!l%6#C3Uu0q*K4dC+`;} zHSbU9)H|fdpYNTVp3M2)(>nDwK0cbwlj;aG0sh{XG+iX{<*=EqZZh}tz z3ZGhcSyF4=vpV&weNw+Fsi{AwQ@_q9^=p!v`b3?2f1lna$Sb#Uvy10->WzI?mkpD; zx_m*We!Wkf@0!#)KS`&4gHO5tH>u@5S*L!JPwF=&HT5Yv_1k@V+FO&_)4r%vzr`o- zHzzgkQ+4VYK6(EwsdavuPQ9;B-g_rC?=R`p@9;_ewxp*1vQGUTpVaS4YU;1()N_4O zzpqlM2kr0idCd>usoG`Y1K4xi6ZWQSR^IcPqo3T0>|sx-Ue9+A`((45PCM!JR7%j8 z|Ef+o&qp5vDy5I0)L+x7=li67f2C3n+9~gea#$+fMmem~r$N51`FvTt%k>4O0Yh`>xGrTOy%6MTCt&DH#6bJdtN(NS{hprvq4LJ-a zkJb~zA+yCu$PQu*WGBIImgDm!_)VIPLl*W!dkFV*j<>W|%sSZsd-7z1b$8{Pi2X#C zXe#y>2Z#g3LE>O>2;Pu=sAz6lZK4*~nOZmFeCo@im8vg69xr@qDYu^JQ%m30d8boL zz5SQhpCdO^KTiJ@nZdf&XtxIoV#8+&a-UlEOu=_FA39Ue%crf!CumcZ_NVXak}2{j znJ1E3GEb}eIsvk!*nxg6O}2t>RH2-uS-tJ!%kpaVedCl#^fQm%a$zrBV86GI zbm~*nyxwkeGeXM8liy;|wI!bKTM&znHH(imizlL3d>X}~C}}JfXcnJn z77s_USQN!#)Zb%XLos@uSja@3w7#id{SSX)YQMwsjv4*eO*#h zU!+qn^+|nWQd3{7Q%}xGQ$cn9OP%^wpS=H^)VzPCQ~y8iz64yS>id81JJ0UrUUW00 zBWKOHlVpwLTHeb24pUYNRrThoxRt2-}9bn zopbIv)$jj&pJ#vXqxXD1YpuQZ+Vk3HEZ9#MiT(fIxGUcgvC2LAHCokq+}(*^oU^Eh zvqh>0$_Kwec9vqkCwrkt?En9IfwunNfxMMZN93*i*0mRWhhGGfZ;tYU?~y&m!V98O zg4~(kh3p9y>~Vpz??(267B}Gz7wIM(wMHs4h#!TqTn>}BbZ&xNLQ{DaSp8G(=hTA# zS8nC(K`HgObCh=$ozGB|bwDSp_dg)pIE#H_Dw|Sx)y-^nM0w+0WKXg1honILVIQ)m zTd=1E%Dx}jGcDMQ2g-f`*-KlnmkgBsAhMUSV9ySe{SdNWV!>W6Q1-*fKFy-VQF#@M z*5ZCd_D3w(sjP}cWB&=+D_U6o(m*YL1lcQFuvZF{{bytk<{mZ`X^$d1vlx2@d)w|8 zWY4j%e3d{ge+=2HTd-Fx5<9hyFS8`ofRSSkYbe%3kE1*#lB`y)(~{iZGN)D|uN4xM z6cYT35?ruck^R%tehwu=9grcHT?sNwv$`Si~GM{G?kp}|j0pDk0+p9sl+hnGCcPf& zBbzmVvMMVHnW*RTQc%w0e?d8iw}zGc_WTse)h1baMKXL}T&|qAPA-K~m4-aA_BmhW zh?J_IQQ#ft*$pYuD!=3YtMbN;bsfbgne7Ni?mjB-+o(IjlngR={Xp=PkN9bnK*?Qi zEkWPdQm*ztCzDw!tX?1b1M8!fXg6wo$h^$5-BhuZMa@R6-S<-bg!0$vadM8b9rh8F z_n^+8471~+Va}rD?19`AXFQsF(HpPplW^l`89cx!=+j;gO8i8ni8b zhsd#;OD}DLUV0YoahZ*eR`A(JL7`qHn!`GL*OM-LsQ|=-1>9x!jHZ8)dND8xKMT zx%Vq~eOZjmg=e?x>qQ2qv1%j6Dvol5V^!o%@XH=!6(z@fjG3RH98oC8v!R$7xfi_9 zqa0Kgs21RxHCS|vj1WrpboCsQnmt`TFEKXO{iu_gcf_F9XKh;K8Bgtj(pzS~ibeik zqpjoOv1tGGjziwXHhM4eq&H>pcw}B`!@MLA<^*JpNw&6iRI-;gpGoZP%eT}D;a$%x zHdDOrIS0yIHV?{XEEC2H8}Z!bThMzS;h#hKH`AWMOhnn$Gnivyk~QnC>IgwuRkeR7 zjjEj_Q{t@p3h8sodpCN$DdytH{D>{{5D(0h#XCS8xQdm4wyeJH zVqM>zlESUce4g)C?@ZKtl&#()J?KqYJPVn}*)op_fVm_xue6E(%RR+^O6O9@yuw!J zWdZ118kt|Q(fOr7biN3g*V-_z_QXuBtU2B7%|;2U$Hr^c)|$X=kQ(BaLrKe3HMgzp zVq|*L#ul%8vITW#%{nJ#8I(zzld`CGpkiJ*=;8MBvdG-t#u{xs^fDCtJrHqgvT`_j zQr?lWj<^LT>ot*Unr?ldJZe41M(bIge1M8Rmmu@IHq37a!dwBFKd@n5=ZV?bi0WA} zqPi5NXlWxwi%<{ibVPL}G3NK{%=0y3rZ54@hI}`atNB?dr|?{uFXZ#ZP>$m7L)ng( zhFQaKULML-yb_cXd3`8H@_Z;q@VQWK7;;WIpu?>3z5A0MlF9z!;9CjI%J=+RU_J&))99CPdhB6OE zj}Up`y-*J8EjL0r4gROB_)LegE1L`DP$u7jPl@7e6LTKZzky5%JT9hzlO-Y(8lr$0*D8VkawmH?~Fh^t}DdwTI>c~nNnUCSI-HkuZyea1PTK< zC(s!6ek9I%JVWJrQpmH}=Q-A2)7A-b-xsEf;{kw;^vg8-2S3pzrO- zn_|+vr<00DapcZ!H_%8UgUOL*B_YypsapZI8U|ZFt)T zz=xFZ4c5)2D8K4}ytxV1@%hFC|Ks!B$lJrR9rX;P z9d$(BaWU5Vj*0PK-+Pd^tPStQ0q}N0-kvu7QI7!nqkECJj7@)(9YBB78F>%bwBLOJ zwBIhsJIIE2U;w;bk$0>O@8|${yCLs68{V@4@ODRDX5&{E0^sd|yw}9Xi8rXLiW_Zx zS+#iMJFM0jc#ZE+Q}OveR0(E#L4wz2ac9>!Nxu3zm9>~e5BLVZzvV5r^`U^WOm-KGjb=gnVsm>brFS^*soA7uc-HFSI-_?tMM_ zVdVYDhWEn&cn2fzw7AG|z!a1B*!>&_DEp_M@K5<8I^H1x^A1Jce|nGW5#$|W)1Ds= zAZ`vr-cdR`j||w(k0S3l9q*WcdGnCBq0RiTegN~s;mBLjX8dt!0OOAl$XnTlw^9JS zBawHdO?+M+KzzA z$0F}Xy14OSz;R<7^7gT*-vUet;k(bI$ zp=R?@Gh|FeIkXuv^tZ5Hj#Dx$IlqlY$)L}UF$rbRX2;OWu+V22R6D3yjUF@D;qf@V z3{SX}fokKEk<;(9fE6E+RNj}ANjt^DnmPV8_y_y^_`cQ$RGK#%K`(x+gL`m z=O>VNludnG-=z0m-?NZ+oDHw_J$h?i%HHaWHnWjG@(r8dvy{USh zi@XhWV}|-g95Yb7^N=^kW^7g^fU((=$a^$dS!>h2^OehvB$u&WYYSW1{aMWU$h*)+ z-vt5a`xNpnwc%Y70Ph0iZDPaQH~`+Kk+-uAZ>Iow7b0(e8{U2a@IHgQD|BasfOj$ScDLc}8UXJL$UD@A zcW?l_OOQ9;hId2&ye}eefer8Y0C<-o?|d8Hc^-J(+>dxgb3bAk$`igHu_rO|e#9={ z??)_0&cAfA^Ur`|=L+QAX=D4ZJlLKZbFD<)?`?R$4S;tQ^8R4MyE_2hmyq{I8{R_! z@V<<^r)+pndf=t@m*u74<)3qyK3S`cwYB8hK~i z%%P@xSPP=&j!BT8Ae(&-(d-Oc6Outczi7m!$6chEU+8!8wX+K)AEndX{I$q9El$a& zAD+?34DM4z7GUMMC{xyv0kOV;tm8~s$9QC= z?v2XKrEenlY*X$?kFq-*qV*_hEnVi#>;<{#bKthZTPQ(~lz8x7#g8rqUs3KtGMGb$ z{jIJz<#;YB18zDfCspinPEoqc%%yJ!pgVPoy|l>fD{rMMS%9PXU?>?MD_ZxvQ2xa4 zhg?-hcpb=M63f>^=90hJX}Iee$CYyz(L9E~gK`gui4iSQvHgQFvEo%Wd8)H_Od6aF zwLbIVOv)i}kNziaCF?kilp9Q>d>5tctC6y&D=D4D#cjfJ?;%^uBx77`0r!u?XPlhI zMaqk1Zk>MU#p{s2x50}WgG72SZs3a-%k01JBlEMSEqH!JpWs&umbuCYq3$1`1Op7Z z{~B%7{aCb<7EF!vAAuH;&4xo+m5qclmkj`aJi{uBmhz~OtRwpnB^#1b#&8R2D0?&_ z@AEjw{5%2f{!a{Lf0h{lvWN@-GM9H>@WQ^#Dx-HrLq>0HUJBWI)YiQoW$qc1Aa*d- zTiHrhV*6a)l*h{KJY%ueK0=;RhFWW8;;~H}d8{*AjVpq!Hi}52+G+#pFvhj5sIlHg zL|$Rqs+M`|lc_AMwZMlPF?n{=`10l^l&MN=w21Z1nEuVplGuZmHk{+sj{ej!7&YFH z5*fDVLN9QJO+v5v7-g7X@ERrZ>f>CCq;%0+7p1SBB3k!mVP<j8Uy)eC^z4=Umj=E@z8_6=Kjcw&DhBUF&gv$yscK3vZT1`FJY}Ni$$<3y7CFzD zaGnl`^E>1`YcfkaljO~|)R?Le#t+$S29!B$7L--lWiZNW&nrS%$ooP$ntzXS4NHs( z-H+)FHyNGhOUiRJrr3o%=S*yVHXxhtM$Q})&ME#j+4~PZZ@nHHDc=d*nP-8JuXJf6O<9C{tY>IGX;wOS;4Qq z9Je3&=WF=&Z^yagr(*U2WUOcsvo8%OW*x6}avw$Rg$C{)Ot^PD;->2N7vx-NQoqXss^4SC z*~f(Qfq*!VBWIoo=dge{e?`t;O*oGQ#CZZa7n*P`2#E6}a;BKH*CdbamFjC{U$5Q) z`3)t|_VxO=t=;vtRGWPf+w3W1UTkQy$}C17FHSmYvlRC#ACO*9+AfG;ioJ~wP8wbSsCvtW+;p`L;=UL<| zZPIp2dThJS=Ay5Nx#$|rT=Xi5|F;{qrNOwW@&iWps&)h_4+pU zMPH7b8&d2t2d;+~c#T=u)y#ozvj#>X=L;r#CNC2EbYAyNqLK3wlh{$tW9*>%f*9mf z_SE&hbSyfU{wEeWV@&jn3P{g5S-cjp zDJ5O^PK5GGL<>z$Q~Gs?9TP6hMZ+gd^dZ>qz^hAP#;tRIrB~Yc!WnkrhF+AISWiU#|Oljg`5c{{u>vN z|CU6~k4*gc!+`vEFZypOLk0@vEoI@`G^T8b&lOD zXEt)SH1XdS0r~I6$eC<%zUGgB)9`A9iNX7aJ$ayFw7S0JMUX%-OCmblkiD8QIQe-@l z7_al%xrfV8l8uS6nuzmB@IBfw5dbj8%~FM7-Xr`^EmZd(Uy!T4a0Gww9|@HRnd4G*g(nae=;zruB=uC0S#_Ei_n#;w>ne%GMRng$vmwNPV%G#&E z&Ux%FIJ>l(*91G~^Mz23;?+@-p1Rw-JzU@BrS>!BtKZ7ahx2>_lnwbAm?0=V@ii#J z=_2&SUiGhm+zWL2&-Y#bvzi)^wyz2IJMy`bVfk4d`$E_3l&^DmPj&u2rIXS$g-LL&sXLO#EraosM*>q5z0C&AJ%=ZW@DkO$zFpp zi^;R?Ng!PfmI7rhmIft^`Qfztc6Kk6-?Pq8?q>4*St@7{%`>26T%Lt*49L5fJeT$q z{C$wW3*{kR0!~5h<5^Jd=cS-L!29zkF|Hm6|6iS5!<7A$YuR>enuW?i7H ziIz$2YEv%5Ag?u9Up^o zAD;~6eoLFyGuV{cjn4!bvsp&f^SbaG`x#Q3~ zG1I{v2YD*onH=SW92GQj4AIEZ0Ocsq$uZo898`2_h#Zwt?RIY~rj~Fp&QspbrhK}x z(D*8$aUak%jxP}!H$pky(VT!-<6)df>3ak6P`!>*eJQ@i$XDIgzEvIDm*Tq-`D)qn z)o{$`CPpw3YrBi++e<`W8Fy<#ZP#FRpsdB}LYa#(t+j|04~s}4Gt5+tQX*~*D5JT2 z=~^3i?*UIa$RCFC5PuQM{d_5u2lyH&_gTh>CTNjx+@*FBrPLEe)RGau127!sxdxj_Z-?xf_Xkc^>qf%5OsM%CV7Iea^u< z4Av`Es&>sG%Z#!{CF7toTgx6o+aEMDv2~<0%8fI7Y1BK;pQ^tWd zA`Y}PAQ|(@IrUAd9&bUernYgQiQ_onrXHQd^JcbfA&7Y1%3yuUhPUDuEp2Vs!Z#b9 zhcWKejDxS#WZHR&w5RM{WIxyntXG5G24yXFi|7YiLHRwq70TUA_CQ)2R)DB-kY5Jn zVSWvihj?=+_wg1`?&mi{d4OwsOsl!bZLV#2JATo|)`qQpv!T&$mxx(MMa`^3+OVy# zVS8c28-xuT3me{OVMDEbWWOE-bBu$$0+fgNU@_|$B4!;!p|qaQwKmw0YFk!*A^RNZ z7qV}0;ulVQLE9H;^|tbhI}AEe<9T^&OZML~M*fx<&E&3C8=R$@cA1Rw^{Y2W) z=qJ*qPW;5mUPbYfI}J8T->ExvU?<{;zu2KCn^SQeW zIyoE1$=>uz;rr^WPM($z&kXmN&gXVHn9sRs(@yN#^&hwE-3Gf-4&9!~cGr6*l&+nS=>c0^dpXvX;=335PQ*v9Fw})SnSI&* zcy}*dQM3O$pr=^RM}cMc^3KRyCn<8iT|221G2hm&FH>U&xfa_8JUxev2JS-sA(W$e z7nEQloRtZm2~_lc&&A4TMPkPw16C`uSp_J2v&*3Dqm0>M)#64dr@{Y}J+kRgc4c#+ z9Lf$t?>m(}2-0%cr3~*}?uNft^RrM+;khtk%;$@t9L3*-%;RH|VYiGkV0@H!MVlN;j$)PgBb;h0 zSqcIhAZ+^r$X3X^Awr2H?YW;c*R@J{Zg=FFsq>#1A|t2V?K0-1H11Hy^&`rM27!io ztbwS5UQp)qV#4}8P>P-=IXHSa&KE$jOAj6_tSo)^sIc{Y$bQt|!FyeJFvV`AdrxFv zV50kc$GTG`> zMb@I9exfYf51IPw>akxS_4pvNwKuKDwl3?D(yc$TMfNY~vqs5t? zjx0abdoEszZ6LChF|}m2OG{F|*#<^RAMt!>5kK&Ukhzx5V`{kWQz_Q5q8+Xl?QjsX zUWhmo_os)wQi@g1=f(o-A=q`3bEPPquFSQrRDBLcrb|rgvz*KNr20_p7*yMX4?!u4 zHU_0;rZSiH1gPC?HW5nL8HLfy88!jVhsALvqjg6%gbhVmhQOPY_pmN7BJIYyvmP*R z?ZX~o!(jX~oaM7oY&09g#zIExf>1VVPG-D)1hG%(X1;QsaXiuA$S@4qdc>=dp=W$> zk>OEft7z&;m%8*M%5U?KZLzL}EDEIm7>;a}O?9i}Qa36R$dkG9OzsF|F8Y~V%AzBY zsY}RPx)s4&C>^W8jA;r}nCMmBgZMt0pAmh_=uqA2XWk#X zn72^%ItEz^L*s*~MHnAY7R~_+*I{a3CM|pj`tHcpjR7_mHrDDCRa+8IsuW86tsMBkz2fe7#vpk_J&ri$!W%Yz|A^N>?LRow6 zU0DgrhujYtaN{w2dq!!AY7HuHo;W!nHy!odtkZLo2R*46BUe*rAY%y~qx&^fs?U<^ zwx5eW`SB2Iu+X;%o^meU`H5?)UCctB zH+A~G?m<7QT|5u^<*+4CR%HjE7UOtv(6x}yMj77Go#luhR% zm-*@OtHu3?hOA<0hRNx1WoM_Wn8W75z6w24orhfJJ8&vjFGpNdAHNK0E}N|owfM5A z#dV@BehX!Lek0W7X#OP16PZ6gljx_EGpWw{r}>Egn(2zg|;~E$M*K^2qK{sylvf4@2*COPauhVN@ z0D3)-TtjtSg9G4Nj9l;PxZd`_MYXYK#jf)U$hc6)xWM8y_Fj0Zn)*1x_j`q%eF|N04N zTgbKj>vEJQGAFKo{p$+E&)4ZY!h^n4U48&M)?h1fPPC7Y58c|V1vfm$#=1ROL-9Qg z*4)BYp@z5VG;HPCcPPG(K)+h-CDiW#pApip2IyDlT0hEHUq;P7&}p{LL)}qauOQc0 z9oOgpxL!rBS9Dx21;Di$xmN19mV4l${9`5f<36~jCu3O~9b;?P{z$F9mIc15Y$}|e z%3{-@%waR3%w@BoY{sDb~h1F(BfS-!eV&2;7IHhC)OHPpXo zdy165zK$%bbYrF!uFphLx^)wK;U9smf8cK*Yb{+CFJ%^ABgyI8a1>)#aZd3|VBE{! zM8-NMjI|vzQr3J6S^Ar>^h?ST>sV$tJ+-S@a=u6DCif|17J|3Y50!li<4LLk;G2=_ zXUb}}`xUfzP&cz2N7}hic%4qJnul|esW&Vs-BhiVlLYS~Ym|vand5q+7&nQrMXXqL zc@G&c7*6B;>0;f5TJw=>23rJg6|q9_h+tob?D}kH{*7ebM}|z@EV_8I+i?Ze8a_a# z#U^#P$k)~&_a^18BiM^sx^ED zUfGe=0)K4CWyYT&Yy-v^CF76#b0t&{`~@&3upLk)vYk*SvG1TvX1k$GVSAxWV+Wut z#tuW7&NiYn+j#?cb8IPF#+I`cY$aR8UScn^Ut&@;>uNcWZMq5EGH>Zl!&PX;6PVLCI z=Z7bzKy(l9c2$FMi*l#l$)3n&L@%w=wWMoZsc3fs^vh$*p(kF=4?~&HyMcbA_!gAF zm_y9zjX!FwvIMLZcLeWMPT)(Ambt@*u&u~_+Jiq+`pW43o2XlDbpHf7_2*Oli|(Hy zL*)QYh;pj6r{ z z9!jNMgxkt`Xr;M)EBt#qemXTuoKo11v3DCkd%iZs&m!nTL zS;eFsXmw*=Kc_K?s@Jbn29q3b?&_6d`Wl%A=_33<*Abp#+KEhKbxfmuXZi-2%<{>) zv!0tMz6)AKA(yfITa+NUDE=KX%{2h zJ}3+ME|frjLezPmNJTf}NUN-1){eAxqZGp|M_Rp$Fw)wC=tFd;%^voBt@8(DnrY%W zGko=&y~uRb&^syjirn;0l#lL1CbPWU{xa=HCbR6=?wF|lE?TsMBOgGxAI}(Pxs6 z`W!``Z6;?^{9F6);6o0=928GFBl>|?tj zYY=7kOyJ991z`87{1l=Z^F=xz@ln2868NrSzeD_2Pj4CLk)4v{zKH(pmUb`3$tv1u z)MrLgnr01GFn;`tMK=9}m<&xJnJyyJ1WJ(I)a-O0Y-fpPo;(f-dO|2vi={xylIx*FBiC*_0k zbkkqRvd~1!1&+r)6xT)I?={#tT$xc$jHsvRl@lXMv>6-gbXS$)Dg#_K*?HtrZqOLp zR)KDfM!i3yZ(9^sdElzWE+Ch3Qbg5DIVqy(Rp?kR${+v6np#A(kVhf&4&Ciy znJ0O>gS=W)ERZ))w9M)al;}9Q=BV62(fYIG&W}ygk>^blp4WZkNkE==O?ck+ktY#(J}}`~=Oa%N@@z2S zS??oHGV*LT;o0PZhl&;QWe6E7N{d*Lg3QKTZcbQF4P{kUQ;Zurig80K zGDp5W;NRHwcNoiWVQI*6n~7yxIUYAq@uC>A)H7kJ>!SWBo^<3HWWqDhN1hDi8EV2a z*hik?$Wz{g$IY4@HU2pVzOWBojZsfRYI`O*{%P%-FJvN1zKKpFT-c7%={)GPAKt)` zI<+@pYwMd%C6Q&U3Cn07b-DmL9e@{oq)r`8*g81YiHb{d45N*R>KLZ9W(*Vg&X4wl zNO-qcj$zc3FDf7Dr=<75oyd0`I5*ExgW|0c~8iJzJ^bSavi)D z2W#ZKA>6y^&c{Kyfo}y{%;XoNmM7rFsBU~Vr`B`inY23ML~j}NI~2LuCU?d zpwADyJTlfwip;wv=O8tb=yzf$wkG04bR}Th%P&E;I;L#3ePEM0^(zD0A;_06V`G#l z8*{)$jWI4ohWeU$Ys0ish8$Q$%YbzmvfQ9yxzTr)ipY|yVY$gQ3*`;66{{W?K3Qt! zeSKq#>1M#{nvQ(E)M@S_)dRyPe9YMHC)lQtnaZv}3pUqS@MhmFC{N+5elB%VPT`yB zG{96RHCvFfir_U4UWvMHw2XuA*~CH0OXP_Sc~+weGI>9%LABzmkfCylajaV@#pxO* z#gc<8w`jcMR@dG^v0RNTw`*AL@SUY9vaB*$uUB5ZGT!|#o(QMgQ#E8MZL&jGGTASd z>c}$4gk_*_EY~2*otk=S=el0pwANN)yduXgHIO}+)_Rv1C5;w*HIYf5gV*_51?Azj zkU{3|QdWv*r24;7+!1ujV;{pDYc*y|zZS-v>dB5IJQ+WnY0t$kjM%%;@5NDi)keMU z)p$r3*B(Me)^4J%dWpKa4jJ`%TAkMwbqY>-v$QI^4>+^g{qS~66dw!a8P*i|f8wV_ z4$(R&MR(Y7$$`DgX6#9qQ~#nHkhWMq}<^r>mWmFJ32R26uoj?B(^5&G@E+Q#Pue8X$u) z3%Z+nqI8mP3%3EC4#8W&>ii?}UW9Uo(E6-mc#b*+ZZ_E8hmhxG`ieH4C)#u)Ad26w)?2{Mc|(P^|} zov0Cjd?7^kTi1d|sBeAbB74t7^S-NxZQn)3`Hmva_ZM+~2;98+iEE?1jPp%Vf)1fL zf2U7z{w72onv{a8CdNB!gOiHs&Q-{l?!#wgD9>+(EDvcS@WZYnFvZdwS*n|ONma*Q zLb0?!mZF^yp;&H4mRcsd)bLH0mdG+hQ!kJBUN5&Gi}CFRH*t?@y>iv@Q4!DkKMXoinjMnHf*0nBF|0M6HsiUOu>Q&@uLb;o!_PiHsGM0wd%9K&&6!N^JTvt-Z zFX45iNH!(2gB6>0@6rKvO=gO&K`#{o6Ul=YzZbtTW(am}7mA}Zau~DpI_IF;gPhlO zK_+81XTN51U6H|CF>5d%6?4r&&sNPua1{06o@#fFo3hz`h;Pg)>Rca+qbG70voQO|(F-|@8QlEixF0!Ul9O>&R(Z8RyDl4* zEa!e%kkP#qD-F@h?b_@E$ZJA zAm0VcImMq5;}gYd+Per8m%Ib9NpST=uJV@l%Z3vV;S)o8E-GF=2YOw_`oZ`?y?bLe zPU!@7lm)e~zkQ?bCe!1T382jZ{vc{&%y{ZoT<(tyW5Hg^{he?Y9yJHgXmUM+svkMa zl=I60$Y(ddw5uN~)(k{^;|m?meVgKV2swtK;*Iw+l~*O4W=k81_{PlW{?*MA(Rb!+`p(Gl zhjM2%JpM5DoyzKxllw@cP#0rHWaqk2?PWA_7++`dk7EpS6j=J$cycUAwU=d3CpFku zTn|z1R;ueE%H2x29x~R!dI-g{Qt*t^@Th0FW!7(}?ULeo8F*^4@yKKL0-Dyx)YIbO zbtKitD4x~8Q;SVN9%Ghor}|KSR)9WWd>z3*Kbwdg#@D0#{(iG% zPqK+P>F=Ly-tpBouYiSA+bDO;$MVN@w((E$_X3lAvZ&RWI?1W{@C5!o-?COm5VcA% z%tD4jONOZggMZe4KQQYj3+vBzY5h6)`wulcejlY}8E#~Ff7x^{GT5z^7)Slul{5dW zztLCgf1rtI`-S!AxwQV1`1{G0o;m3s^URNZwT(8Sy&`NgUuPTtYIRFsl5Y@_Kc$nL ziZ=`J_j4?3brw;p6vNZV5ZubZLS!)J9R26VA)okKzjta{?K7f&pK)2g&*JZm`RAS5 zhN|D^kl__e4|=JH9<&G<>~=HkqcWw#^T@E&Qiml))L}6))U#x$OECBsgFf@sN43%O zPvN64pswmz*+0p*`6~H0nvtyX&gxjcL?=1rH!tGvw`)cuJ6w%O{Ikv1zS>4xt4cPo zv3#k{HvUQeO<DtFIHaN-?~F3>z#N))$fCO=LK%8A1KzY6L~;@D?%*veaQ< z5p{SQ8H{gUI_;+@9o|8Pm6kdzFQN|bs#emy+o9Z&r*}S_>=D0*4D&5@m{&v{)*-{s z8ejS)Et7R&U0FBQo%MiI&3#~(W;h$gMzb+&EE^AJktf0V=4q@D_7mJhip${lec-g2 zaz^?_D5t^uX&iXwLOGNjguR5RxJzNb4^a+sDy`zij7xJx#-(qd+`#uhIg`IGb|%I` zUoeB0fJpQxe;@UwyypY_o!1k3)XQDR;odjAIR`Q&u#-?GvfrUhVrQUCW`9AM!Y)9W z#&|L1{jL}&)7gi(le?Y&5)&uR?p4Lz?;|E}@KHLhM;+sfh3^I>7IR+rC5WA<4N;1A zo1jc&o1si%TcJ#5pF)|!K8G@meF0@L_9c|*EERO@%UZ$T+xZzd2md1b2qjD|77M#p z$|;e4>_PT(l<~bmO4kjDR7|65h6`Pb6S_8p`b=OqK$*yHgffZcLYd5Nf-;3Qhcb=b z3}rEP3zX^XHz;$UJ{4UzqHHI8sMAe|m0)@LH!is-Cl^0P{1U~Y@jh9W3oBB!v>DM$ zh0rhZ5q%4yUmQX&>m&MBL@ysguizv4Cy0Jo2>o&&(LY7>D?;d3`iTA+qF)t4zuHIi z&k?;^2>lu#(YGOb%@F#vF3>L`qDBSi`FdlI_!is~&tUICnZ-VYG8^;dUk6cmi10ixw;cG?D_XqTRar_&&O>_nS0yTLmC6<-t<#+{t8NZy|li!YC)eY%i z&xQU}d;b#A8-&ms`G~#)(Hn=*o47##Z`55X%yO>aUwNv#ukov^wuHtHa?<%hv;oX=NA$gj-Ym-B(a$6Lt`PbjAJH!$`rZ)wejm~Q zM)ZRr^us=)vv`@o@~05`&px7aME@m(e%wd&C`3OILjTQ2^k_u?J%s*;kLWRo{$~jN zFCWok5&e7!{cj)9;}D&vt1ITw>CX39sF_VXqQ{2N<9$R=K=i~Ada{q`iHM#WLNDec zdJ>{%gwRX)h@On-St0aNKBA`}`b8o1i+w~-Mf9>E^zuHUry+WU5c*|4q8CH-%R}f_ z_=uj4=vRi&uksN+1JSPzp;z+}y*Q#@6GE@)BYFu$zcz$^osa05i2lD2`t>f*{~N1c za-}{CHF3B4RT96dAJV^}3;n4+q7-({6Ip54~IQC96KqIn?kqrA-j30b9G%l@B`wW+XcIp1Xs!e6Bi zlt)>q-se`)Vp>C)&F+M@t{YcggkQri zL7Cd8$3U)9CE`wn8~*lhCRoK(nXm2%V5-Ktft0*RF?9u;N+{&d!){SKz6Q#>co#UE zkjE>a#MD``JAgj{^1dnOtJ*=C#O{JJncWR#3fyK^&R5+FWidFpsGP6rAtc@n{la$s zo;XW(DKcG~62+SGrM#cXDY9(BRuuqSJ+CnwtY4M&6g&?=nZf!%nZ^1+naw_c6C7_b z86g)#uQ-Zt2TM-mRp6B42>u9^tNCM4=JVS?y5amuC`a-FuuK7$durr4UY&%F)We^aPQW zL_1!|g44I*T#VZBidTObB>ZKt@Ry-J`OA56)<^Z1EB=H2VjN3VMky&fTE!^Y!w&-s z7H!0L3Vfg)zZqKGG=2`s$8fB7CCW#Qu&dzjmc_?FluCq%l*U%Xr$dxVhKQ7|ISrlz z=XKRLSLqkuu0q^Z8r+wCz|BG2Q5xJaKHy%BxZ^aq6CB`rt^cDC-!H~-f1YSlMTu=K zARf2lCn2ikaSp9%60eH-Q1xF8f44=W_a_eYrf{nx?q?d@Z9d>$gSgu@xI28nt%0~- zYjD5u0kY)9m?lrY-JzgM+6q*>!8eDW035F@5+Z`9=q3zq-E2 zH#RW&uJ=X0@gQFYD}b_S8Pl|V%vcy{Oyc!WK4+uV8Dg|rAHQ+4wnp_e4G?p-CbrCV z5L-$Ub0%ZEt_HKH;jBKCaFYxy>V7?GAw-)s{23_M@v5S~Ziv$NONoZraCbhN7p*-{ z2DyT1&y7&hqRBTEycuOK zT3mZp$hXK>`DEN^>5F`eg?vi_kna{>Z4+$|wEq4qxPZSID<6 z0QuVZBHsr>zV*J!_n4^PJAILFgOG2Nuky+IZR?ACn}vK^1CXzsFYR`!O*2diWyWk-+4;&lmZQ z1}0xmU*tO$n0&oZK5E_ae*E1Fnsv(;9jsdxZN2H&!1R8=mwGuFn0&o`k?&Ms^7ZjW zzSDup*Vh;M&IBf3KVRfK8<>0#`Xb-Cz~t-ii+mSAz6{1P{Mo0|?t=|L`KWW(#(ih) zJ7`5YCniq|eg~^KkKvg?dHQwWe?+ov2FV`!k4Vj;t<(O-N>Mzt1hliJd^pNw=AnMGCqrJf=1jH{nbmlN4g0^bOD4}z z?Sr_vhF>R6Q;kFk55voy%2_I^p7Zhd?ru-~+b!;G&^59LABB4S+mh`x#DdW%ncv>2 zjoyt!^d5suW^Lo&w#)MdyNvyh)YwvkWaIuLlC3aEHvT^%*{cT0Cj3Vvd)pvc!GA=u zbq2{M{zoMH&>-2Q|A=H84U#?fACc^1gJhHcBa&?~NH*m^BH3pK$)^5CB-?I~Y#K_I zN{nbTU@n`(N>MCu!`L}9BMR;fwq%8fSS%w^GmC8mFJmb0$xx$5 ztkKVp7kxpltzP3FDIu7EO!T?u7Xb`_Ml>}n{Rv3>A1NGvZ6*)j7RBA$=K>4O@SWRJ{YlVFd!`*tuL2a)zKS8#;h{( zMWTZs=>~k4Xe-2v8GJU%=DyCPPhST%$zcD3GK*agWj6Z-EMuK}!06f1r*9TMy;0QJ z9EUOmVW%C!Leg4FCWIMit+~GY(bM2Z8`#HC#&YRX3kg4(r}HCf)zaHa#aW0EFR~|* z%WNJ-`HHq)?=14 zIdY-QVK+gU%bG*kj7=2LW;&FNj~6j#k%g}`j*&5EfzDUl^ba!rS;;a8q}afuERPGh zmJqT$t&=6oMPFqfi??W6&zlxfs8M*KPKr{56jmN{Gt@{1y9LTDb}N)_dT|-+1`1!9 zB7Ef;l#054c{?!GXC)xxz(%$oJm4UE7QgHrlg7%zOL*nkC9DFwlwHOuvddW|b_J`< zu4GjpBZU2W=5vU%8D4iQ4%&2NcVwhNKcl?7Hx%;tD6j7+xqK#uUfpwFe^$Qqn8vTI z>QD9PMY{TQ>3hq4LY5Jxra+bvW`#p!D#ENp92T!en7fGxL-khL+V*RNTpsFq z17C%*W+uZ7n9t<@h9rleC)>bZ(n&&j#yz5KZ56TO3emP+c36MzV~73R=#1!`MFRZw>u`D&DPD|(R|3)|1mm6to!*}0X4 z)p_|EorNh6lD$tY5dmcHvlbDkF~+|aov#tmxjf__%;T@2wEsq%-6`7a>nOqMBpE%N zS$vnKzkkD_#i={d-5?rdvHPIRX7@vx!}>s3l|2Y$BQ_AqT=p=O&6r%*X#^`eEMj%% z23XBeR(IZnsQn55l<(o=6QjlYPVB!D7554YzlHWGg)NJU8gJw8hlQfXP$FtjvufvO zfpWm6>RBLlMfDw&Cr@_{$eE{<*R;)d9eN6dEc=bC1hVWm-t!4r#*@7o?_TE+nX1+I z5odC840v`fcyV7gDLDn^Wm&8wc)ap1byIdz=*?yd?*qgut-&i<1iTLsua^ezz9QhQ zN4&l|{9WaguwIo?to5So zz6J4?#m9y+Q071m%A`;Z$}DV^N?WDSwj$bR5op^yqJ4sB+au6+ctraY(Y}sA`^F>M zXNdN61lltm(LP7C?;_B4c|_ZWXnP{i_IgD70?`IUpgm-PmQ1W!$=tcsAnp`GW@DK< zw?tAjWN7ZiMzVpBe_B0no0b#@y@JvwR8v+{N#FYt(VmNt^LYz7GYL7h^HdpUN5GiN zea5lZVXr2SkAhuTAfE8e z@9=jEi)cX;ELxCzi+YRHnVLFP^y$S9 zdbX%H30@U-DkJ8VLV`mmf%|q`=*g>o5H?V=l;VbAXAK*Wt1e8bp zgumMo;ZdJhcocf?7u~3~uu}NYY5aP5AU%KpfkMZ#Jqu+AgayG6oUFR(5k)(1txY6>1&mi>)b8*H(>*1J{PDGfV5 z!{Kct<>jjSP>$sJP>$gFAX6Uy0?KLdESI#t-`w{8{yjvx$($FFdlS@?`+jGn@b@U> zrhIg(@P%mn_2z%H{){%1(PA@LuYjL`vJ;PSsK-$_Q&5)0;;%mqM32us)yFhZA8`)# z_!47yJpTR*n;1^j?FG>`6A1`F0rfbGN$wlP;)|1}zh2AO1P5I7l5f@VN*WcUv4u!Q(V5K3}4@JT{B(RDh)&X0r zbYg5Ncj~qII(`In^^TLw*KrO;m~(gy*r}h3Sv%5^yK-!7=P5>%=vA!OvEjg5d*Vhc?XTM zRU;8Iv+&DbZEZziox)gN646c;A(o#(tWt<|x(Hb3gg=xI5 zJvL<~mcyO}n`ht(!XVgVQ%;Gi^ReK4EJ1je>~Z9nA{!+Po?G&55~CM6lDQbUDSu(b zl`%{i{PhLfdZDmlip%w#vWON{+yIpit^XQ>*ARj3U3 zOZtO*yC(pX`<>8fVD~((tlswIdnHp2n$~x z5Ua5lmb#7*-c-pUtGw})B-&*Pl-Vo|$~<-|N_i>zcPLl$OqhpF;kBWh$eTbpig$-{ z1n&XmNd6L(1-uEc4(C_=W2|d5td$+I8r!S4dYuB12;vd4QY*JrROuX@RiRqHtgm!Y zU&TdzWs3T$596rSya$x|d^VI*_#r4K^5amB;3uFQ$%~0s!K*`A!1F|XU8TxKjH-*y z+C;;eO(UCz=-MPBc+o zVzit$9U2JBRS(E=mh)=SzOMO)SyM%{uHg%7E_i!BUo6_2m6n}g7CMEW5i|Ij4q0V8 zEGb%lY0>(#Me835(J-Gs3gv3P4$3L~IFu84CAc{RLwVT2APCiO}_X&|o#M4iPP%H-d5s?*`>WJ_E`T{BbBp@`X^2 z;ya-%;A4fZwH>m$)zzx?_ZO}II?t@$Mv|QcYaP$5_EEyBUI&YM{hvctS+AFhdaWqx zwUVgUC!w}h^DR*3^HgX#Q+OjNC-N>(j^N!yTN(uANd7LA1^hlyuXP==8tc`Yg@+0Y zU+<8$=(-kabgk!*)u^ktdMzjFwLY>^J=ijcIOkbqn4>DUFd8Jt8$`Q#e3CYAka7Z{ zJ-ds!@4>v)*AP)(4gX=w)fYWjqkovSmtei&A7=ek^k9vVm0DYpUeW;izTLbJe53fv zjreT^pFG8zw=?1GP5xo)tp-cv@m$ZWSBW@kH6ON$*nNbjG(}ctYwAuiVapuY&wxkF z;Wr_=JWHyq6mrk4-bz2K-uE7;%L3lavsJYoz2ZO|-()q%1ss|#gMRu9TvtO1lGSt8h=3!LrX>@_|Y z%Jw`4#tnD#C}`0gc^s6T`5h<=C3746T_YQrDU3T2BMt87d9__z#3)__jCP1ovIrRM z5u=<929>Q+)}h?h)xNxNNORlzF63!kJo2>#uh>6ousa}j6CE~Hk9XsDaW=YB7#$HK z+XjQW74jhTy;YfP>C%c#MN8-lEj^CQbC+7X_5<&4&rdSa24y4G8p!4A%y$yQYtNKT zdgC|6;Pir5e^+LL%6ZzfBD9&lh|$Bw&!`>tuCRKcWW(!+Se=U}g|g!1iClQ{MIWzy z%J-T+|5^1L}>OS~~FlIZ?h6B!SUK#o* zWhLPu#Jdc3QDp9h3P~}LA4Fycp%4dve0`b3%@eor}5hD#&IkdOa<^6T4SJjSUjpJ8syjTTn?P2sD9>29Z7?^#5^)lNf4A!!?NEHbtRL0&S1xn}@U0-FV85}N~MDw_vo zCYu0~f5m5l#pkg^HVV`Te_9N;9f=b=ny zFF={fUW77}6@YwS^JhT5Cqe!(DBl+$`KVrX1)yZJvH0CG7*)$mv-14lRLHxhaM|l9 zZKt)`DnLzQ<0EW0&R{$DxGxLbi4nNteZYOy1b2dKTv>0wOB63INOd8Y5xiEzCYzSpCSRkJ(R;7H(SVtd$EtA=^ z5p^`hP)Afd+6X9R*;M?lZD@9?-V|15rxeCC{5nBof$A-0_Hik3p)rz@tI5579}E2= zeX!7=ABAgd<68hXi9HT>3&+Rlh#U4pO6Si2C7aE_?>+&$_15LM_7Z=#3E3j!#N!6p zsQyuVuXiSXtvmdUu$AJ&{WTX7d*#3V9h9veJ$Q*9}Pa#^k{kzBgL*PcX-312R zqWQxC%^FU1jX!J?{_wOzn;6^lpCG%wzh8)G&fB!n)_)0`EQql6GX|Sbwl>Op-bCJK zeUSHWlRA9PATQP4cnM|P6ANW3i-$6ktpf{u$)ig|vH8#v7a?LrmQJ6U_VFH<5I*7*CT~^37{mhOQB3<6`{;zZvo;CUJi7A3h%I*2}5RW_ZpJ08UGk*!usaZk}U?s3? zpiE`8pv+`dF-E+Mee#z)>|GRET|h`=^#oc&fp#7G)hmd$gNHqfiaD>M4iAOq1WNuO zr#n`w@$1H>F^AHm2}qy7T0oh^S_*yc1RKA~)}S8W@|#M;z{f_w=eAJs18K8k!(uPdPCvPrNWb%s>{Uy9-tp^W3Nqm-RXD6bYM?U;%T zPrwSu!|XXIr?cmwoWZ&SHsrSiNe95L2xpu54p_(fn7@J8&%ug!3Li+$MP+2T570`o zUQjm2@mexqo;5^?HxZqxC2drE08kUzD-p5rEyM|Xup7ia0`dI_#J61|_5+jzHW11r zHV8^s(E!A6x%AF=5U;-r-yACB8U|%D%M*wn0^)aE`qR6JI9TIN)Xelf{3aj1QSz88 z`xGNe#KQbkz4<}eP22B{2ALAr%OF#D{IU)i!jXwW)Yk1-p>bs0zK@8`>sHo;tb_4@ zm;|vQToWH4p8J}Rbx;6^$EKcoCP?g*&HaFvw2YVWhbCj_ZOL4ALbvStTTlN$n0zsqSl`C0Wpbf)Yx-_ z2YYG}7YIac4Q(_*r0i*oXbS;XjcBL9o}2mGBBE_VbTy(;ZRTVA{US}9dDc~%u^J`I z(dTBw*N&2@8qv1G#h_;b`z)drZb3}vtx%rQG3Kr)1!McUd@JH9t3%4@E)QO7qh!?9 z@e)zT+caMD2_kxJg-Zc3nSG&Yg`Xm#wiQw`YVEjO*fBDiedgMZ+Gw^C5cNIP=ZNSn zn!P0KsBJ6TifG4IgdMff>)n$g;EgRrBvP46nA9XAO(YTNW~4|e<*Mh&^_QL(nO84$BsAF;NxNUWLc zLBwqy*GxVE!~}K_>N-4j`~fk&)y!vrn8*$RVz|xhMZ|E;P?5}PPXDuJPQL&w)1D_m z-08^Ih}G47$U{X9ZM|;;d6U>-P5ar8C|=voc0f#KKWf^~0Yr4u#wC`Yq{ zP>yE@VJ7@09}Z*Dcll+|y58WsU?rw2>&AXU7D{_@BS?+iPMSS^xbVeLS9|IEqmy>=B^yZ)?wx$YFS0A=OsH)NpdL1N0)U3sJC zG-!JV`xc_KdX9Oyh|*Vy_eodGPhP8qBmE2o&Wb?Qv6ng+QzVrk`~;$R&>xtm4dm)BN*n;ai;c8QZ~?b09ah0_|UKhy<@toC@g8w!c%@J{eh59b-YeS#VoSXr$3sTKyYg;}ra+LuTZiMQ81?Bgm7$N&u1? z`%@85+a4(_87Ddc7VOUfmKrD05K9{;oay$5(5)DL-&v;{Re#+;#F{@(jf36@f$Pv=}mFX0y?78(LXuEshvtVa%nRUmhp&8c;Tt zalH@75*gP^Ae#I7>IYbnaXk~UwDm=`S0(2~4$HzXFBoE}Grjr?y|~5?OPc6K)t9XI zL889W0V^u16rv1_s4q$;>Cb}=_9<;*9|}v>+fbq3wVh>q zmMc%lb*VdRgNthKx>qU3w1!?8l9(i)k{naD)- z%TC5=<8ho;9`T*&IZ5cbUFdlUepwKqC)K|@?}yhwZ+sW8fGm`+Nxz*8@6h_$1nSL`3`d#i>zgY(TDtXp#p3v_%q2CpV zGABYmDlRMc8I>{me9bs&fo2@#pI>bgesv}CQF1*Cnq{*p`0Ir*c2{rm$Xh(rYR^@w zUMBbdsD4pIH)+cT^hqD_y}uIs4w(T<(9qvj=0Hzing{B|jfos~0JnQSroP!f!t{j<;Q!amm^ z8`bVl!We1g!E{yFPxs zL2!rfkW*i03hoB@b#a&6iq#TXL;PB?nmp;K%%o|nO%t)H5q>=-F7lojCHW)b>l^Uv zAuhijCBANqUypS8^*HhMjrjE#-PdX?wVI=E1*?^1pNe{Gf*6}cOIF{{q;y{)_;c~w zWfuHavHS~QF2S1O*PlZyS5{L}*_ZH_vOY}LTqB4NIqW7xXpro#=9-DGo8i|@U4GqC zeBB(sZsGFl+r-x`@atB(uc?~b36^Wem^O^u!9nc@9lzY**(>>{k?oe;^*nPIC@ z+}jbOxO)+qs*4|mMxF83hjbcID>Bs}0t{#Mp)6o;KtDN-9R%$ldk5^ry~8JicdX%4 zpj^khIF#pgyQsb$|Ri zO7}IT$**9K40aOAo7pKS`?BTGHze{`pq#}|W4|)Mp zp3v+e{B>QOW|UoOK?KZUgYfGrv5|coWtTI;E@y>Z&I!95gM7e={5X`e_yx4f!-!6e zq@%Kw5kL%-ec53AhGi)yUDP>{ieNR1Nq}!lup#(uT$VbENrJzWQ#bT&J14E+E71yu zA`4~VG@;KU`0JD`ckv`g#FJt8brqNKq`2UI6u(Y)$=y+SRvv!c!KG(4gnmAU4acwR z$47b=WwjK+Jp#W@a>-p$SZySJeW^>UDenv9uzdXbm`m;gF$WlhUys-Ikd)pzf_pT6 zUBxALb)okd{JN@6Z>lwCg111PKqzl!rG@8=6Rml?XwBJKa`ZeF(J3^m@!xY1W?U)QCVkTDt@+2&W`qgf^F#f^r_e0>;bgXl*hwxIw(s7I6w9Qgan~ zd;4aPMZLE@6~C;Q<$ML^tZ1{-@XIqU+iVkI4_e zb!DBmyQ!lbgFIh@rPNw~92wjoR<%W(=}^PY!s1WhuRG~1PT8l1u+J>~y1LFj)Xv6i z{H|7(_8g&-`GDf>Bcz^#-#_3|>i**Ex%hQImtUugujk>{X}YheRwhTRb)fDGc^a&! zWy87eClM>WO6Rplcr~I&n2)%WHS>fgo0`j42%@eU=AHrCcQv=R9x$|BHs4qu22ZV>C(B0l2~(aG5OB&-+p;?Fv? zSv}DbpTl3*)wM**0~*2C*=!Mh-2i3^N)`k8?hoaQT6=4IwM#U;+VhA^VHLtRS*)?J zaT6$W7=w8s=gVQ-#Q0&Twds7ZXDo^G4q$P_dI7Phb=3wiBWupCfYHlVo(>+Zo(xvc z1TR4x%FfL|r$qK5{<&`~OUAFP${eRgOT8nnk2Ffh(L&b}m z!TJy5v%r?q`6~|PZ!diCRs40^2p{xn$7?lheKjIeJ)s-VuVswCY3Z<3YMYfOE@QY45pQ3zP#)R4;CY%EO^)caf#Pw=Z?fCEw z#BwH6OUpR*CgM;&-W4pWoWPeS**c4rBlWxmrH?jl7;lovJ7jMoGSyy`6+C4ZxVx@y zC>gBUyLJxnu0t8#!{6NpGAR4d?ZhpRM;x}OZ#CBG% zSBrW*V&ZG>yTYj`aF&?he1JHVfAkan@ge@YPlSI^b-EtE`V#shd0$RB9g#`4(~t1G z{yJZvVuabNl_NxU)8=dgVp9I3_3442`yFg6*igM4dA%6jZbU3E@;r$0Y(fmmAGH0c zHhb$J>`y;N9I76bz94~Z#$PLafs(~up30(ZV%5fyG=0GqhjI)R{;_Ns0mHwQyGy69a_W#nPkN6gGo#>s&zSHO(_8&_2@A0cbU96`#X9|1m!mnpU z*vqTGd<*jxb)9ZEB2)73!Qbic&v}*Mphkut5Szj>&ZX-c=F)o|Vp+v{?P|(Chql>| zze|F;)y_vLztr}59mO2-1~G@6g?-)uhq_FI@mNQ^O|HF1-Wo8~d*lZl>T(Ewr+){` zjV?WfE=`0kb5NJV4*7q?-|629qkO}vK8tDkxt|c5(nZE=886J%Mvfp3)pqBLw)->w zdR|1^rN&f4piUdHg@BOFx`929u%n2x0Oo=6r3{LH5qzD?e!+96(NWLBu7~paaC6oP z;J^6%)jB6FGtwVng7W-jhX+QLR6|Atm1+;zr^o|Mb*P; z{M{N||3!WG2Y&aO?mNnUZwdRI!LQ$lupjlUvL>0p{={#UHA&~=lXt|oXYt$jBEF?` z{R_W(U#BZoPue%cJ_P<-*ix8RujH3OdpU*ghMhxf%6C43?>XBDV#jCjbxHOK{9eh6Gm`y{5hx*wl3wN+ zmF#jS`4@=a(NSwb`nix0O|G3#D6%j3LRjKUDDPljL3tm$2T!e*M~GS>&wN=I@+NoT9gdfgHq?`%9-lU@G7{p2c^lk!V(iRqQt9K>h0oKhcZZO z?h+V#gf;gHYqk>BjB|*h)g(ou$qCp2>CEFjpnRgS>Pdl;;1EUI-i$3R(IJY=EL8>a zIb|^I{-E3$Omc`K+v|R?=ws{_XsMCyH5pN;8kQN=OGA4-%Tw^1gW#)j&6)c8CtxoL ztrVhWR4RUbIMjM6PdB#NdLnML10S6$c7&DnP6|bO+0P(JHv0w2Ty_bdwB>W5Y|o21 zw8L@uvN@AEZcf0+Q^{_V4liOT5}e^w{LVlYWz|S|Q$w!eIkR3W$e9pT91%{1tVeN{ zz%Nb%XLv1^vX-_rozb*|IwCG)A|{2R_23xI4tITll7%SLNLB7woB_+LI~Ei_;)w|RCB&f%OWlB7bCMpBXvqCrv`5Rz1)$rw?Y=XofZlA)5RGE?RvDJ8Q+ zW-^6%KYRW5(aQZl?w_9jdtL8)T~E*R+4foY_q*0_4SVh3-h1D{Hx&uWI3$Ntn?LlNJ--das)hgkwcP(7Tw$AG7uW*ITKIjk z)9aJXt~HbXMJ`#rdGbn^OY*nBe!NgW4aBIl~nV%gm6Ffh!fMGhD2B z!rwkKQGT+S=eEzAY5NoQDrKwrZNJCcKBl|2FBaw!>)2kt8NE7GKh7DQ+&S=A%$DoG zo;t~7A^wJ@c<67>_p)*>9jgue=zs8{U+kj4Mj3rJN>4C36H@ogCBmLN6|?8A4NC~l zX7oKbhJH%@4VT<*hB|-SP|b8x`N}RzsF)MSGmv?eAn=I zS+T}m^r(^X@`W2aH-~w~nl;`-7u=V4OQ=td(>^_X1#R2f6k*xHJj6(;WN&7_G1XRO z`MJF{%r92mZwqz7cP09|`(xdIa!sCDyFJV^RtrY&tzfITt{i}Mh`k`Xz3C5s)7DE*~)GfqBpBg@KW z7fxd%TtiA{D=Yo)Gplzu*SR{#+3aM-$0U1i=#SMuRYKiSeoaUA>&Y?SSTu{RvW+R} z%KV1;yQTe^z1uW({Si|w^v7ze>Y?tI1Zk@v_E?_#L(lD=C)Swq$HWT8L^>-YqlU7cy|}88 zTF<8$O(#t!SI?SCzZ`v5pq&!T=kB<(6=UkSeL(3i;_f-Pn=w(@RCi;#rmMw+N`FO4 zjyHF^^6z1pVwzC?Y5S1UFZ1ucI18GS>@`xKk$G6@k9h63kjPJ(;2k_iOf99qlG~=M zxNW+d+nW2bH1-jtU*7R9`Bwdm0w%w4}K{jpULUkKZh$n&XxaY=#RC1-WP74 zRm1JGjgpWx%dcR@ z+5^Zv#lcgGkJ|^Rb8t8D6Jai~yz;HpLzJA~JQ;d+ac50)`)bTPYii?)H&2DGTErWi zTiTd&%G04ECv!^h9;x7(TdX<7A5-1jm>TZJRJ|~-SbqQc=sLt**-XWs(biY`W$s?i ztUKL4%KoE+9nZ3(Z4mlnjmak{Gx%Ost~xwUTgh2utogTL=y)oee-pWzH&$8oC@aA{ z!$?TvNT5-8#+W`5tBnq`#kDn)T^)a5*}*>J>ex7pA=X%uad^EOhmFE<_-yEnRkpm( z{5JQD!Lu&@m)xA$B=pCs^K+CJ?3178-(bJ?oU&Xw{&;~B`4)|NXR+PKQSKz$H1x;n zpXWo}OJ4uPs;gYP_m6oRQ1T?(Oj+g&q3-2NC{y++_wk$K|JSgLF(FSz9b!y8Vc)mCa1I2UzIld7Yn=ZLrQbhxo9m9?O7d5EiX*HAs^e4S&p)d+l#nQozP7(O|Bk5%8R+_}lMuBJQO z-XK4HWNde3yrW#aJwo++=i`l4uFR{WasTr;p{KIk@vhunp?d83a&=?lpLa&~4s(eW zvs?|FK*=e_vgOUPW!d8E**?mcC*w>o6Wu;P(ew@X`5R+?^UyEM{}XT9i!~mmQPyLo zf9RZgemul#pXJP6$!3O&v=MuX^pOE!9eW@4*MHeWgKht%Az>0Vn&578?!y-+wdQ7J#6Z;{noJ`C|hN{ zEAMBPrOYIHey<&^boR;})bAJP&qYsUii`=JvG%)TL*1ru3r>moEvwwqzJ;=^*~PJb z@XJlo3$aGpHaziWhl{csQD%#bS2|_e-zjCXzguiS44tw1@OL}~%`Uf>PBasgvk)ja9$&l#*aFu}n78DJx54ma?qRLtWSN+d{0e znz=o77FS|l#>z(fMVLn{=UZ-+WphrM0l!o_OH*c|$>EhbTj})697D93B6E~Zzn*cl z=|($O>GY$Gcg}gCGuAwl%hfQRWwMzc&NI7X&NF$@bENOQ39h^a%18reqRH=^NzS=2 zbjI2S7lpbc#;ET8R+*hHqbz#C?H?8^%lazRwN&r_3b`6x!7|x=L$7Cyd>!TyYm7>i zMO>7LF3Kg!D3^x1qO?eG-W7Wcu|a|_En<~El7&FTxBX+7<9hbyfD%ivg)aUNNtbjrS> zBF<7~BhIt-yU-bHJ6s#;^jD4UrWB5rXpiICvvv#A>S=^0;8m_i`sOLtzN$D)%=AQ?g zbFXu5RysSoqlbr_Q;r_CD4lXWPp;%u;^;4<-KuoT6@prnnR&{ulIS(sarxhM+Qm;!LQI^-nx!SSpZnkh# zvDp5hbjtDFn>Z_*@@$tU%~7SZgSTDEZ>AnoI*l8z9Vs(`tII);99KFcZoGE#oF|md zxADZAcbzl%^@;uVq|*7Ki?*v*=ATMu85eDL&v{De^vjG8?M8cA>GaD?=bUGhPJhmm zchmo+bT)7!p{J{7@Cyl%$XTVci8qGix314Aoq61`b8lCs96NIv&|SlgHIwvpp8hP8 zO&g-k7_mxcIX4mpI=_tDh|+nB8wrCwXS&cCYqmVeRkjo})H%~n6qU%cP)N| zbIG;%49ZC5IOIK?l}!eB9Fj3~#yZN+6zWE)&n^9HkGC`T47Hh+Wn~FkUnjA`}+{ZD| zIb}Z289HN)w8?nl&BrVgOs;UGWr{h{+Pfp(sm}E!?V2f)TN!D3w>3?3PT88`luou- zjvZ!r&UmHMA8~PR#N|;s{n_yvcSM+1>73=_{DNh&Dd6Utd`f3#*Fv+sdL}5Hezd{) za}%4Wbatl9WHZ;5IiLRAZSyOgW8HO-`OYcVK?*3HK|K@ALa&}l7dX?p4zd_eocWq% z9@L1@l-SOxvrJPUZ!-))wh*6xk}`&z712X2~CMrCysXs%#ZGGyKW*L}^-Ouf0m?+~8u|$THd7fHQrhn9?b|zuA>3 zS2C_vI`4M#z*bjs8P|u!mCk$ImbKkEZ*iyj=zP&7y&2?e#XNh_m@-e;Ta?aou7zy= zpoQ||+-+}FI@96ddvBKA%@}u8$ET zUk>M#(N|vStnNl%F3(v(>GaF2Otc&Aol2))=Dp5YQR$SnjU(D*BV*_;r89WODc?wsU4rBkj_7sFYN?<<4(Jw@r<;qLG&?#h%q{HiLQ zC7kCvmdU0%eVH**P3ip99dVZwzjIcRuDleM$)+LB^pQuDPHCNLVWdIp z)K)qlck{sguH;6PxzRqVbUxwcftt?Q*g5Mco&LG(9-K|=V@jtSk;+qlTip@qI_*Vexz=M&B;_pvqzov~WxnNasse(ilOtKCs{ zJ<3Yp$;n`AYN(9zDYs2Da8BvJMoMQrw@ozkoQ;*v#?I4(W$ID(vr4BQZ8NtWHc>kL zXkT#7=af$Wd@CJo8@$m=cdfoDHH)S2`QGUU|_urB|9Moef>DH20h@ zD4l+pFS{0cQR(!{Y~h?QDV^EeF=PuDtsFx(S2`QJ7J9|2=gUfG6W2nodCnF}XLeWS z8_xNpt7l84v$gZIWtnVR>f zk-qCZU0L$PhjYHJbPjT@(_PA>j)(0VN~eFX-5z(ZT`Q$?jys0z>B^L=wyl*;!?Re) zrnl#8qjbu%o_%pzQ;0gRvTc=4IdbWbvy^#@7CLL&h0a)`V4y24^$4`RvOL*$4RPhY zLwS4cn@Z;}JPBq5%Vg69XZlD7Wu)&p=LakkO~-J&9*Q|$rDew8DrMyA;#O6iG7u6}YX@Q%`%-)&V> zT*>S7ukGGkC{EyqV^l+nGJGMY<`SGn{7@%Vg7& zw#^vnu5`+iMql83*i_{>xsL6jbS`tV$81-!%pN_JP8qLrah5Xui1w`QrF6bO~BYl+4ubp$LbIMiCzDlRmb2-k`?XsWJDfL|GoHFA3E1f&s zxc$b(EaP^7(pj7lmuOZy=YH0+Mg}UKa<%3=oXO@(+V+GUbV<(dol~x#4OTj(g?_+U z$_#ZQVaO#p*E^@Q?a&LHX;h+6S2LuAw&3CWRo6npl}@SW zHk_r*NLSAhm*m{xoKnw`N~c7-(?u)2^4=vmcX`hDmCkrKYyOTi!K`pcPNS60tGxS& zHZg$}dSjPo>U13q#JwDVOorxY?UK1Tjg8!2Jz;!^UB@N6O?uP%Xv(J zVB45Q&u58zq;#%vWkzr&n8~hHCMuo&y&%UZbEuu9bgp$}rgvpZJtzMQ=TsN%6s5C; z8#i)~-C3fIL_StJ{d%5r_54KX%t#I6O=efmZ*lIopDLZ}TnlCOT4<`$DMzE(aayy+ z-CgmS(wWmmo73sA$2(6xmcf&W@|{SQNUW`DMwokIfzE$Refl20ZcRM(1DRqFtDyh)-0Y&1-dLiH@>l1))j5~B`YlyDe{;^; zy)u{m3+D<~=5nQTw=1)}SLO<(^G-bR<}T;_#+A8J>GZ#~3Enr=#I900_qk{*dC`8O zbjlW88E5J@@!u+)2V9v|T$yWJJy$E8t(`N)i+0VwaISS_ey4OEa%EQY%3P~--j65V z)O5~uuFUV1&ZDl(2fZ@ah0a*p>k;Ra zYd!0g&f~6rk2>cD*D^mTon_rw%VS=dKP#OlU72;AQ|6xy|H8S^Mf;1=dCHafq*vxf zrPDu-EXbM5P`gR#^n2wvbNWWRS?ToK_Jnh837xTy>7J&Byu&U0C9|!{^5px`26$7< z5Xv)=ZAzzH=V^#D^*YaXrBm)=ZH%+Bk$e4jD4lX0y@{)70Y>2}`>WC^Pvtko+0eYt z>^#rzR63=Fn&C`++Vr>38LLO+H+h@$eU-7hl%5rw^|UuHQd&W?Tj`PCS(9Hu_+9Cd zmi&b`Ij*vMl%DZ?|B+;xyV&+BJ<``1xITB%>{EK=iH>*K;!g6$9QocfR$EJbg6Hg3 z*#k;X3u;o?yyANHpwjai>NxW!?bg5^QhMZ<9sa;m-yXgs&oSpYqV&icGk*);m3b-c zcBN~#qsnsRO^S2aXPq?1lpg7ybiCtz74J9D#rB44>((sunG;G+Th!Kk!r19)PbxhU z+tscO{#1I}Q%;hx%p}LmDW%8oX2N_Xc-G$7)1fEUu|#~L{K~}{Wf>h@o4w`Q>@Q^* zoeM}AXO(5hHel$>2KL+~d46}>jmfU-e|cg>o>j4-CsupCLtTP5FGrO6E@9o%DPxlP zY%F`qlROKft4B9CR<2}R-eEH+Ju+wHp^fX?j7pEhmWiXIlf27E7n_Xzh0GbNZ067t ztBt>7Oa|}L$)YTy2leM$R`!E$*sMyA)PI+o|FS7PaxZHpwy!KUyV4_Ld7~SbIYLjY z`uAeYG&Jv+oXRr#Q2zwepJlSir7UA0Wdv=UTUmzmV^KGU#VI|Hus<(vK42c-Y2uY0 z8Oxd6Sk9yL$o^ua+h62WdgPd9GyPJ-=2Lo#xcRjf>qjd1wO1gbTQ+|IopXu$6U#?bqTJeoWlIi5iDX#QL zY(KEQoHW-cJu+VAGcT>OC6pfN8~Js@YeP@0vHt;m6C7V$r__%L`|^5aOyd|`)_lma zp(&~KNZseSW9w4NxIPNUeraVHlZYtE^rP=jnj4fJ>Blp!AIm7?n&R3k+1#isL!OCz zm{InEEvxj%+`7cgtv4w>pSZ1lD$8V3PFa^}VO?%kmLcPDo!gFYQF^5BKX!e8t1_+` zVc*}TEJNawUv|A+>5*fxdG1{F4y8x-`QK6h8n(Q$F0))4mogQU`Y%HLoywSGtbFOl zN=0QEslQBhm$D4`=3qHv_&IyG(j#ppzw%m18CU8r72TuMSIRHH&`?hO%w<`} z+^h7=M;&Jtvdm|yC_QqWW3L-q_bEMc+&a`9x27mPi-{`1EMb{!s)n9e`-f%WwpC48 zhK#QvZhTc&mT@Hf<&684Wk`Gd?%Jz{(({-*H)zg&d#9z>5+XzMz@b>qKvC{crENXWf@!C*vjC>R#Rme?b#0p*Mgo`ma&a8c+Vi$ zG&b30O3x1G*~v25yrA?*zi)HXK~UP?qr*Wpp?5*)A8`R?0FyaL1vErnRyRIrorv?zT~u z(b9d-l4#m0%aHcXNLw|q?UbH#)IGu2q+pb_S9%_G`-sPBubt*iWnI!G$$Zg4Sw=~I zD>KQIW?9*ERC+S=4O>1l(p?LBOX-n0`B^t7cT(16Z}|OJXJr`~XkGT*EPI)^l^(g; zlEpdSQF`RM@grB&Y^-OUk>D;C?XN>2_vywQ+lvgxMu$a{_D z_^rFrBm2wYZhzTB>4_t%IFpBEKGRd_k^3lGGj5FSrS#;Z1fE#oSn*lgTj`NL9p>&k z=o5Nk&E<*Vw$@jvFMvLQe(9%-Nqz;e5XXqd_E(m1z|EID@ue&ynYKzW1z9GWfl5y; zcP%)0hmf&@lyO}i)_t(DjKXe|+)aNNJ4ES`xazvNhAKVsE9`mQ_!_44$XKcB#>#M| zM}BpEpetuY=!rGHmc~ao%d2ZfD$D5Mz5@%MbT{@rrAMyozwJElD?L}b?Q0R=gIBks zlpZ-=T;RTI{vhjM*& zWi;h3%sA7GWj-@W>5+aZ;`(K>(sMmMQrVPZ$uG1iJvX?%ywUaL$4bvlsJojgoX0G- zpM;)R{c^LL{}Roo$};4*>{d#uY^Ewbx1&xrN zrAMw;XU0>*&QN;fOzbXKqnS!iCDcjgLFTfPW|q=Z8Bd%kjOQBrxzh6}M{zYx6`YTm zFO;6F&XeLiUn)H^XIf%gWoIir)m$62Vc(R)&IvuS#%8|oJZ`SCjQc5r`+1nl-mvqO zo|<^#%!4fRnfXeO>}PAc{pt@Oya$>_$-5~b%+7u#blwxvpsl(UI8SY?-mo>*gTQFtwW zxw4EqI5TZx`mld`!mdzyB(8$4{wtLpdE0@U1Fcee$#jnAju z_*|#-$T*nBerJ{a;gUS7-I)GS>5=_gdbfXDuk>8*+Muv&gP)Y1`fda~!?LdVIrPNZ z-Wsug&(HDD24xx2W(%3$SJ_{bWjyPS2UE;OWf}4dwMiV;PPChp9vPcQ+}PZ#^gKsP zy={{4%(YvTbr}$Tzq(af#`BcH{UHX|8}KE?rr~pePK_#L+N>msFKag zEbEwGl^$v5cz1laGxWq7V=cpD+uxLB$lUadyYF(B(j(^sCEfYJZe?7rx^elY`CVCt z+GdbH@WpkKB)N zgPZ#fhMrh`-zIG1L&`E_e)-vzaaie*F?rB!`$v=>xfXB*w7Ls^%0)Ft???WnR0 zX|DyYF2|Ifer&->W~jRkeq0&Xo5U5&;U|>(9pUl(No7njR+4#6>zMiTk~~G6=hP*6 ziaF0|WnCtR-?5%i>g5Twzm)2ZY+1aGOR4VU)aR7yx1HMLkoy5*ZAb5-j^mjkow}>b zJEBxi;L1y~Nq2!dt#>|kC-0#q{RQf@-t*KGb@1C+y10A0xHBr%eNiWyOiFcsr_QWY z4|I`aQK|>Kyt69RL!COCQa#+Mvn$nd446Zy9_jMVsZ_s@+L~NS^#@L!Td5xF)NxAn zc+@E-Ua6ko)OnQZiKq*jyh`O`gbGt`w$ex+L8#aTe9Uf^bk zB&B+~i#u7Vo{2iyT&7fijyi=W!*%n?moD!@O7$GnmCfZ!^*q$ZT%lAiaFG;Nsu!WQ zrifDgmCO4|rFw}|7geg4xk#>3s#iF5F{OGH>UeXtQhk?;ySP&QE$S3=jZ(eFO@mosoug-8@~ajRBt5j zWK%||-t5#jD%D$2r&x{O-l8zPF+r^{>`axR;qV9^({*E9;d!lsov+*w<*;J zP+N1mQZ09f+@Vw-BJUJaUa3CfBB`KMA4Q#H?o_JfE#VcF>fda1kzfzsm#a%dTz^aiuzV z1|-GQRjLb-H{YHq)mNZ?*gUCJzm*W={ghH&#MSa?rMf8Ue5RgKUChN@U#TvRns4Bg z>Jm=injmQay)n(es-|N_9!{PBe{`YWc?SS*5x(d8e2rN_833@#Z(+o@kxs_#LaY+5MQ z_d0b;rTRY9*1V!rS9R)FmFntF{hCr;19hT#U8&CHj%MCasvjWlf~J*H{g8{hwNhQn zsoN;kwOuXSD%EvRH#F^(>c?Fq?Um{$occ|r`YEUGpj6jG%`d z!5&KWE99MGdMeegxk!2`)o-BYH=dO0)~E}bK1y|47fD~Gy1k2}pHkhy<=tPYe#^x@ zK&h7J;sz?!on736lanQf%|}Z0c+~mLM5TIyi)4~gJ<+KrE7g;o zdWus0u~UDnRDbH!pD5L(I37$fpDNW=-8h-5RR8SuX`d<8pSifFDb>?a=Qq=p>X|O@ z8A^5V2I3SmQ>p%(ysMd6O7)khlg;N!^&F@ELaCnT)L$yq3!HkkQoRUuWiv;q9_D7Y zxk~jfw0A)>PpSUO#XVoC?!}$c@n(Tiy@b5u%|fMm8ER`5Db@0Zlf_E)3YYg+O7$wI z{#vR27Im^&qExSO>ZMBcS{KPOrFtFef@Zl={UhqiW`$DylZ#}fQeA@k*IqZPlCArTSMF$@fb2Z>W>ZI;DEI zi~9$qdXJ0bN2PinYHQXj)kE?G`-Y#C>H{wCpOxxEF76FV^%0l%FG{t%ooJ&{eU!W_ zn@vjfanuFPW~KTh>J+m@sg`H|wkp-9T$^lDs?VTKHrtizQhYC!Y<4KsXIilM(Qk~Vs zyN84pan#oQrBs)2d7o9PuXE~iN_9yWiOH#J@6t|fmFhAslE?+>w6@E#s9!eeE>Nen zU6yl^q*tnML7ieUDAl*QxHBr%cQ|z>rMd#@f+n+4T@iJX$)Z%>?IOvlRNv#&*_7&g zQCpK;slLy}okOXv>hjL1R9AO-=TfR`piVTom1=pOKTfHBz(o?TR6pcunMbLvg}SE6 zt5nx^dFNBA>o|3SQvHd$+LEYLKko9*uT(#QI@uIZs-JS|B&E6@>Nu0ERF`viyk4eM zHz4oZOhKi(p^LkaQr#G}HJ2;ZO z9(9trUa9Wj)FqYbw@{~;Qc87a)K8ky7pT)ZhIj|{U~|I->a>m_x}fI%?@(<`H~!|O zRHjGxZ?Ev*KHUtajE3K1Gp1H1 zW4?mYnT_cK#j_am1}uYmS&dl(w`DVC0-S(*vm4%aW_T*vm>Y8#^A>yuC2|_m3RXaY zT*fqkS&%WeF^@pzIAb1#@nGYPc>vyr15iGXF+JcHD3RBgHn0K;FW3lW^Ro^cp=1GLy1*?-#&m1P>K7W;-+~WXwtEa=9@-LgOop znGW|9Hf9i1Dnffe`74dt1A~iFXXt$u<-ohej9CYTuQujING@(nTe#*LV_t*BP^5%0 ztD)_+q+drlaOL&1Jk{cV)iHyKkM2E%r^z8rlD>!Iw;#=HqDAm1(YF-(Hv!TPPV6&!^Mw;3}G z(%)`O4HyEEJB)c8ro&mdue>p%;W$*RfESKJ^*d=p*a{^o8uJRwg{*fmCSd_weK&mu zhoMd-V?KaA@bEq40e4kq?7_|V8q)!Oh9XtyFE{}A+(+G@eu^^3Y4vG z%y5X@Z_IOW2wtyY%w~9@Ciz2~2k=A6gOmf$Kg76#mJb_q3ZAM(z2NajjF|^TY8&$o z?18F}GUlO99b>k@J&zgl5tM$Mu?iLH8uK+g^aOE3y(iJZJx`&7Vo%eb@G%^La`lX9 z4fEiN`fO9M1hO`u?V%t12uaTn7c77x4QUtn3W_#jJi}x-1g|z`Y(tx8=_g2OLjS=o zc;h*?W9ZV|0?uQOht8?1tyZ!iZyKUfC|t!O704W(NXCoF=jZJ48A zBNS^(o53NttsUDH%mZHQZtjN85dS9I6pVmvP^^P7FTr#;4HY}GT|w@*m``91r0Ya~ zz%l61nZARpZyQq+2EaN$);8z^8BsN_V3z z;4?S^WxDe>dQLqb& zjW?zdOoZQ|^oPtLFb^_JU@Sv-_!e?}M7zOvkb5HI2719akbM&KHFSgJP-C(&Jz*6* zIED6s)sXXJ+6RWfdPw+$@d*Rqdx-xOJ@kRqkaH?}=m9Gs>u0nl^n}$AH;uUz2E#VE zays>aNpKKun87>&v*1s-eJ0y8%m+J*wt=p&3^IJq+yxzB9-M{;zMw4F3YUM$yaXd* zGZdW77=yv^BjlNb9(uwG$TXMypeL+=xOsdIyq52- zmmcE0+7kxA8pytZ?E*T(0yqPA z{K7T|pTkioyOC`YCc|zhx`{T25%3e_-ON~k9B9 zoG=!{C!yL-W8Q;JQ0O;~rCmhD0`9p754(aw$KD-W7;RM{UpJNah2V3CE z1LOf?U=t)Bqz=#>zJW}KC>P#@xo`q*I7}We4z@snBgQ-igW(6r^#^kVbb`5X0?HpH z4wwoD;hJM?Kkxzk0{MVXP{EPVkC2R&xd#^Zvc@kehclwT54z2JaRM-Y;|t8uD(U z5wHQ`x&Dv>onbMQ$z{z;FdlY7QSOj=21dayD8xI^f?p%;11llIeJi&@bNCQ8Ljk^f zt_8he31r~P*}c#Xro&z+!gZ#{U;wOyj69ok7j%GGa0G7UF0SVAA#8!d+_m^9^n~EK z%ReFbwzCn8f#BC*;mE4s9 zt>81*3&o3aeh>X%C77$IKeT{Zun(>;##2!6K5T%*t9hq0^oM2e7nCV(O-q;zzeAyG zctQ-iz+5;5rAiPFd;r@a@mlhMjxZDULecB!9~c0uA^r8%+yc#D6s&{HCHb9XXaVD4 zGsKr7Mi>TbAbn|k&kx#upG|7jd!vw!$?>MIVzGr zw1kPU3G&~?c!zE<7Y@OdcUw~%y22bd0VOICKlFjca0+g?hxlPItcCQIX=7*x@4*^~ z+{=@O&B$SO7<$=zWw4UEoXD2SrlQK@V5}N1%9B<{{_-i{LnvsKyhA z&=0adumFxi@fxH-A6NuOp;%4IfL^cwj>1(B5Fbo~U*WC? zsUxfg^AK$VyKZ$;*T)yp&QJGeUMU{aS7|8?4#E7g+=fO z6s^O22=BlSsQ4It3a8-O$7wUz2?=$rsRD1nN3a31J;C+^FThCn6RvrZXX#)#Y=gL` z$RFN@>97OhpQet`9Nvd-;V-zZ9&;>AhF>6Secn9@-QWw@4T%kyi{Vum3*STJ8O96L zgQ>6;ay7K30=xhtU?rS_YZ}q-@Gi`RoshRN+X1wI4`20UAJGSO5p1P*eH}+QKB*09l@=&)``Y1Yg5ZxU!iw4?#!x6t+O=7nswb z7kmXtFVbeP1TK4tcwre7YHrPoun^L}Onbuw*bA4npbcOF!K@G+c)8gJo;15lw8 ze%K5pJG0%vL^uUi-)5VEJ#gDQ#10$a>UVkC5EjB&sMdw~5oSQ7E8pe82v`akyK(mx z^nuxsxjStS17I7J>|sqCSO)oeQcw5<&Ok~p`X6>c>E6tB@G<-ZMf%Vm@EM$hyZbT* z;YYZvALAEB!#*g}pKTImLu3H^MyLbBVHq5QA_F;ofPU~ZWE{kJg?i8xzJ)x4=_BX_ zli@Iw9m0FpVFK)jq@m0$@E$CM$S}%-C!i}#g`dF=XFG!zU?9weop8+vYaWC*;C)yE z`yua0-VXu|pexLTO>o(JY?sg!Ccz%K_I+y}fY;$Y*aVl2qTOK-tcUy`SaTN_<2;;58TlYa#bU-nj{{z<5{%M@9)5+alZg`= zz$jP?Ii@f-K_{38e?r-hIUa_IuoJR>!aNRd!CW{Amw(E(0Rv$TWShzy3mst&oPaW) z(Vs8@c0i$Nj0NZbv*9@0FrED~41_h1Z3g*38<+`);kucODHs9s;S}67i!|s2<6sk< zgTkNF|Ii5Dg&D8|GJL^y3Qt0Rm;syM92EW%4>W>z;UicH`{AnDj1zbrhQe&v0y*X| z{-7!Jg)dz#d4L&s+kHp$klht&n{Ib3QbH9xxL& zL)L|~2h@PpFdmk{QAk=u+d&I>4_3e#D7KhmU1$yCVJ)Qpim?DsKo^(}o8Sy2f6aJ= zmtY7iggubBgs~6L!!TG5hahn&V-OyJwlEG>!3ik3jQJ1VfDd2=`~i8F(;mkmnorQ_u){!7SJcS-xd# zLS5(#(_kZHSk3$kk3t9d2!4cfP<##bgIAzGEP&r3%Xb_%!=um%#=&yf4{>X$3p@!O zVH|u1r=jroY*X+8^n@w!Go)L`{0McS4UB|^upe^$z_^FH&<;L;uVEMD_>uV;9)?yh z5*EYnkZV0Ys0(kxI9LsTz~w)&KZ56>H_U)v;2d23Gy5`l9=gILSP#dbzy`)YJPX}n z60C>QaP=?b3C*A@On{~E8)VqXn1D*q06M}bm=9aw99*%9xfq^;b}$0w!bUg^Nt-!O zgr}erjE04<70yASEsQN_09|1MEQQ}7!&dqdYQl>!7-qr`a1`=vV{AZO=nP|E5o`mq zoiPXxz)R2zX23=`4M{uLXFvn!1e0MU?13!5QZ7`1#_%?bg~hNP>`p$1n(!j@gvqcH z_CS{3hzsgMdl(6GU?-&C#TbOz@G1;|sjvnPLeAaHvrq?Khfy#ec0=6n%s=oLybdE_ zG5iiW_OS1SD)0<+g(ud5 zAK)Y;9%CO1k3wr03Ugo!oQ1;2nSbF~=mt|@4IG4=CukR_1udZ$Oo3&v7jm9t{(y(z zW#|Vp;3qf@h5lrWLPK~LCc@Y7E1ZKOr)XDb03Bg0EQF144vL)Sb7%tH;bT}1`ykU9 zK8Ny958A;fm<^l3{>8QrRiGif3BzCptb?PF_bhD#HQ+_)1`}Zg{0e8G&^eB6;3;Si z@4-CS3}>N`iI@uTIJAagFca3n5y)vHra0UOO`r>mg?X?6PC@=i#M}b4;1%cvAHy=( z4e8TGOcA&n8o*mH8s@-8I0KiZkC;24HZ+GmFd0_CKFFLQVv0dUcpO^8Aeav8;3(wI z7%|sDb!Y-zU@RwdwnLIuAd61+h_1NSi(fji*|Xa&KO`@wUl!BbViGXlXKufct172!!} z4TE7idAIV zeu85V&oAPYg6i-byaQuk0c?U(keG-5f(PM6=nfNLF>HmuAc0>*zY(g#a}fOM^%z(H zo8TnmR2utBt z_zRNwrMsKpA$SRTz(=qIc7WlH?gimCcobfNzVI=ugx!#Vx5O8L;1|7~fL1UFrokH6 z3z?H6<|?=wo`$wC6lTKra0s$p#&!dhpdPe?Aut2h!a>Mhkp6^w;TdQTLt!SYhJBEw z5cxnQcmi6%AeaVgU_WHNJYuefd!RnFhvD!!`~XKF*A$QumX0#Sx7F%90-p<3+N4#VLAK;>8_5LE1*0)4zEHl zm;}pU8=QsY;^YI5Knv&%lVLgh2I;OLA1DvCp(XTzDX;=|LHZIAQy3~hU3dcq!e_7= z_Cc0w8DDTGJOQm>5KMzLuphEsM}NXS@HDiAp)eD^heMF#dNgns)P+}}H+%$(VH2Ey zxRMcbEmVf5p%wIpDXioS;`P#;=Bf0zPGVGEpqxYFbYmEmb<1$|)>d<|RR zPl&q#9aMrR;dST>li+LE0)IkW8FWw?o`zP?7bd~iunCSqt{d4_;4Y{OuR?G52o}R8 zI03oJ(k^fp)P8dFTWqVFs**-yz+t%vEqR)P(1t zBMgUWuo8B{IY_*X?F~}k8E6NCVJfVIop25c+>Q>aK_hq*2E$ZX4m;p9O&hC2vcAwY=hH~?@n}31?oc^ z7zm%hQrHHkAzwvwkOK9g4fKa8uoSkzX~=gM#{p0U>O(8&4^v<%Y=hH~?{4yg6nF;O zz(Du}mctJC3lb~Qeoze>!J9A?rou|t3Fn}|J?t0Zes~r-!f==YtKoM@SDF5Wo8dut z4m!bbm;tNdcd+*|H^EI%6P|-kFdSyUYS;y~3gyC$a6dc?9bqU;gKuCLoPz@Qp@VAh z477v6Fcp@=RyYAUQ`kn}4tN-vLPr<^pTH8>1VqUz+uQ- zjcowR!Trz>+CV?}2o}J4H~<-{bBqc%LRF{_Z$NJt4|8E1?1jkv)D22Q6?h6>g&r^l zzJ%{!H=Kin8jKIP2kJr#=nA7?7JLgk;SA)d$?+oG1$E#hcn3zpbXW=7;ZMl@0CNyj zfJdMibb?_p6_&vkI1V`;jF_TuJ3Iu>K?fKNAH&zM5&nRz4>1?PEl?90LpvA%lVB12 z42K}o!|XrdCa4b2Kx^m=6JS342>T&@Eyfs>ffT3*uR|{w2Xo+i*aP+vj^&{g+zU^_ zE6^QA!xyjycEMT5SDWJns05G0%g_bhhnesV{0gTb{!!+5s0fe3i|{s#fN8J-w!ulr zRfppuC=a#Zd3Xzk!l$qlHp4N<{usyKa2q@bP2f!!1XJKE_yvwYmdDx8!_80w8bMp= z4-;V_`~(LfV_mjkC=1n~0kncX@FC2DA7CG(dxGOrxB>2ir{Oi|31eY4tcBmfJjq-G zC807r0WF~$d;p)rYWNNQg1k?$4~4toF=!6&!h0|SR>2N91#wSvo&k44ZFm7X!*KWv zmcv#!0Xgfj{lgvbFf@gZFa$nHXtkhuZdKa_*} zp&_(^e((`2fc0v+ps1I*IZx|1AVIAy+NJF-NC=FHMDR>onz!>-tCc!5# z4Wj?!{6G93xta8=2mb}nX9WLcbpLVG| zuOR(OCv7 z@MU8y=)-WGPmK-wDv|EtCH_9U4i?%ipQ%@!@)A(S+&2=X~EtKK$AgKCUym zJky7H2LH1CxSZ3w5`s8_5fzk{H;gYBJ3(6TS-eXR@=b3tvmT^L9Dn~Uu}I#jd5NDn z08i?Akk{Y&1bGI31!b}Q^KTq&5yYL9n6vYDF4Ac)o8S}~T-j`S{F{zCq$f24G5K{0 zJ`3tc+q<$du#|cPF$ccCJ$~K97knoAAR<|py2|JAUcRa2rk0cXcTmSH#4j-ixp99e zb>hB1`q|oikl_C2zC~B}jMTxeQ^v4<8K{HQEzdu6f7dSc&>a%qlGXq9tBf*7=w(>QWW`ALbyDc$v6{am^y_ zc`2=Wv4Afq$o(m0onQWsok9P4={D%@)c1Wc z#081x|C9{R|9SD13&hbmUm&=6ZfSiQoo%#IH0PHHg8!n1#|2sWddc$wL6DEjBIth?I&|FrVjo;_7w_Am*YVdUowBZ()&FXK%uh0NvV3RBn=;S8gwxr%d)t4(pvGD?_h z&2{E_Q<5`{(&h#p6~57wH8+`ZoN?U38OLp$aol0bbIx(6smNK!-KG-f9hEunsKPl% z3g;ZvOm)sWYH-%^0B0Q!@p~q<%p<0@d6aXH$N1i|F6SRlny1XuoP*Ri4a_sVNuUwu zAgF1J_M!nTOL(iXK>*<$u;Tijk_OW14eb@qB&(w4HN?G3h!z0sDnH`#Lb zW_ydh)!t@rw|Cg`wt~IWRnWHpN!8)ogWpzpY_w+6U}|_96SQ ztz{pvwe6#}j(yBNZtL17?34B>`?RfR>)QtQ8Qah{vW@MtwuybtHnq>&X7&a9qJ7CW zw=dfkwxxZ=zG`2yuiH0lE8E((v2ATT+upuuJJ^o)E!)XfE{QD*}-;*9cqVhGv)|8(!OWkx1;O_cC;O1$J%jry#3Hlupilp zc9NZJr`V6}C-zf2)qZBD+39wMooQ#;&+QlXOFP@nv2*P_JKrv_3+*Di*nVZdwoB|% zyUZ@PE9^?U%6?7H`^_CtKDX|+a2~- zZjkxS?y|e>?{<&fYxmjx_JBQT4{O8JKm6`#^o!c*Mlpq|I-msv@*J^w7jB}9RB}ZHuTzA*8Qc_%TEcuUE;k8X|!i_ z>!p?A=jpF!bvet@Pmf;D9uJh>ZzBIW!le|^_)9;wi?568;u`-`=_5boQgiUVnsq;azmC#7vW!lbI3-=$ z?NXPGU2BWW&qvlJa_On)TKMVF>yqN9`#tM_>Zhkwim&(AMIU@~6?~r+Ed4R*r)$=w z)_x9>e{_0uitm#33@#p7Mt_=Cir?dYzl+}gR8k}oS^A$!O7Ih|vE5UuyU;*zDf z{B=q3m(h9|nUbFD^^2tVvHAH(x_HGU?JrA73GP7PeS~fqJ=!JR|J2v}>Ee|XKmX_) zDN8@yUzZl}Q)E5b8(m^_itmd4G_4fhCF`PWltw#C%)uQYypPCR z`n@UZl7nbuJ-DAFZI>vcHInX^8(o$rMe>n4%F>V1&%xJd*2OEzMy`&2ZvMKAF-ehi zarrr+-3u@nimX>k?1&GOgUAl^3s3TKW8MrT^!xA#I!1 zb|>i)?SEdDzSe&4>s|lvEB*GAX#Etw*8aNRJJGJ_6kqSJr`10HNzX=mqf^o<_y0z^ zUtfRSFUwC4?!-!+XZ&={dRlp=<(0jLd@4r~Qo6tNz0v7urTDIYw=TW*@4Vu=)EuJq ze*5^5GX*XEv-EL8eLqORt}P$)|{MHdUS5SGDjM%CmLVrmmZxS zT}pIHv@5MrqP_olieI{BJox%cEnV{0`BiH6>)$Zcy;*HMJ zcln?C>HfM#Azbx@^X+!{CxaRC0$bdWpuiqkF5LWo_?NwKC&))S^7%< z?95k6x}TEPy5#BSODTIRKOR|+ zE-S5Q{d9@b&rR}?Qv4XwTK7wj*7%?L>;AU`(o>S+Yoc@ePg10mf0u*bN|J-b8NHNJ z{B*zE=yXYu)(-AQPrV*h%v+ZnMC0e?>m}V+O3r?|Uw1!Ul=7*h`=v+cBN{*5U-!qS zq+jY%>gAUr@kHm7R=OzVQ^`%D%II2EmeILgJSDotF0N1OQ^`l7lBH~qk}fgJ(vMcw zr566u*Z6gm9Q-!)UD2`0r@qTik#)&Uwgo@MUl&bUODWfnN=lSGWnFShD?;&#QZ%CX zmwxGfx?j7D-bnEEvhMdt^rwD`pJ#Ns|Ea9YGNUV9^nSXZgRF}(dKs3;m;@|S+OQi`7zqMZwp*%3;25(e_itNQ#9)`Ry8q5Zqdq%r^}~)DgJtN zZvQW*q*c>PjalXp-<4LI_^p?gM)JA%r+!(Q_55xIi&pwGu)pprB|SPGN%xoHl5cfo zT|Si*f9a?DE??uv;A_O|e;S?J#r4u(ep#{}=UORxDY;!dU1HELB?iAPzSpl^bX|Ox zd>TChB|Tc{=j@m0D`m7?c`;MQDy_Vi^fm)WAoGf`)$MOS!%`RUee-uZvPrWL-+}Bk?to?w3`V=K)h|;pZTG z6Uj|9g}IX}^%z^yqxU$zQgV}JoO`}q?sv`0vxlkq_$5mIvJ|~2MdRlj{i#GE>9X`o z_iK^bKEd<*lK;hXmeJMN^^~s^uOEs3sh{qbF17R9L=%Ir@$2QU`#JktglMFF3ZH+Q zh2d$=;LRM8BJ1+)i7dq>`S==HmrtclWIg&$W-0Ls*VlfYqWANZ6w&)iUz6JY!P_`e z>vCcIzFzW?dPyzP$~jdT<<~B{NBpRK<;80!pGNnH(YASlD)R%9G#D!B1%6ct#vlst&C2QvixOqd-^V4DeKXCKZa<%r1;VLDSlb9 z?&sit8eOihj9%C1{rvqLq9gG?mG$WS{S;aEmy)NS;_Ll9{q$&;uatFP6P@DM#n0J~ zL|ndC*3;7a-ixpMIr~aK|L6#PrN3Uz9otJvbgd=bFHzRhQu^tBDQTtq`HRM{g`b0d z-H-O)<>|-ZuU|Zdi`UWjic+JGE7U=MWu9S}s35I)DFDzowdXKOT+# zKi5RJmE`HyLe`^G{L=k)koAk#B|1+(x3t#%7}C=GyY%R2qiYmhx}-$cH(D7Tm0zOh zqg`pG`?>iVzc>AKUoY!^>Cy4~pGJH2Dbe|8QuO&pE2Hy|)<}w8nN|+}F5NHJ?;}a~ zKTRu6aYdJ&R(iD3Pl+zk|McSPm+DPRpH}+COZPwh&vUrc){_#&r72yb@oVI-ODTSY z(dGIYeOZ2*X(ZiO`sc`gx}QT@>AuEaPpjP|pXl78 zQ~nQo=K&x!u|DugW=l4kJr%JxnlzHYOQB+w?BV=`}IF_0w^Rd)@)xDB)R=28oCg&hx)RL&_(`h4JK5j~)=AWET za>>>7>Q+@&^HI|$%gHI#81;NrSxuv!W4bbkc#(tnR`(KKN^;rK9Z`)}^GPSG#}!9O zE`xeT$+E~<&0kHU##gC#@E7 zFk3d?iER`6@!g#>74zI6fq3Uas`;Kv_$oZbx?9YjRb-w3zFz2&9-?P2$0CynR ze9wLOe9wEpH=Fl)-}vI3?|CT9`8+f}-}4AQ>+|q5^F5EsFyAwq_qhV*g)W8po{xsP zpsV>T&}_cvT0VF57|4^QVJX;lHb-=Yt8EuUx^(kBUkh_St4rhgo^OxO_k26d{oI`S zo?n3Zp4Y-0&@c1(o`v*oJVvb9e9tc^^F6-{^F6=7=X?H2&iDKR%qT79d;S`>JP-3i ze+Tcv5bH3klNWowXM4RR%=f$%%mTdwp9i`vm)LyJZQ!59iGLB^65_UkxGfva_q?Yv z-}AolnV|ban&Bzp#XQk$kNx6vM6+3<*?iG#&;9u<(uw>M(h$C#%`wfSA&&W;XTf~W zXTW^VXUO@U=fZr?XTW^Vb78*c1zesFGLz==`JOLQ=6k*j=6${hmSwPJ^F24j=X-8| z`JNk;`JQiaIp6c+Fy}K{QqT9ime2S6T$cHsUx)dg-++0f#eB~XxR~$xW0)zL&G-Bf z%>JA_-*Zea(KpjK*SFBy=v(S-^{w=+^=g-7rm?AP4BMnrvC=BP50D$>HpLE=zaB{`Ha(SzG*hw^bart^#J`FZIJ%0Hdr5` z57LL~2kHmu!}Npo;ra;u5PhV6D7-*#opw0nG+KX0J4*kXezg8~{TO|W-V=_|T|WUz z64Oidll8%nf3JA#Zje`neu_R>uhggLReCjqrs*|$tzM_sLw@gQGxb^esrqU9>G~P^ zY&Z_fZLU5Kj@cc;6(F-b&V#(iK1-D6A7S6e zAvcyQ+k2`06Q7xzrTGrD#WeR3pS61<-|tsA193L&EZJV-d`kHloy=pF!kMp!b7yD% zBiHsf+D82c{YU*L{b&6b{W+fNANrsAMwnMz)XL9LFRVO?8e%hrf2-BQQQFWgX!OT0?7T9j&L+>2IJ1 zcHT@EF?}{2pwFRa(z$dVolnoA3+O_6Ha&+9)6b*l(+lW@^cb+;MRYN}h+a%Dp_kG@ z`epQTdIeoducTMetLZX&4ZW5&(Cg@EeK}o0Z-8<>sEyHA(p%`Q^ftPRuBNxsJLsLX z4ZWM*1G-v6H)!|MkF^IuYu)H0px4Lf+}u!CVh*(P2ZvK()Z{CS`4)EA^nJcOh2KY($BcozMx;yujqREHQfLj?+rTd zLkG}}bWhN940PBRLW8-^_ko(|$B#Ff&H?RA2A$2NuWKjMXh4*r6tu%?;s~z)DmZ_p z(U?9B{ttnAnaFi}Fzpx^12uObXqnYcJ=D(#sL!5(6QDkZ@tT?k^|V)DB-GU#S_QAK zccI2kfjT>ib_EN2C4LqUXrIBEEr*&oFJ1#5QdR@U=&T0TfWD6nTuaC3_fw|lPeDJc zL9aT)!E~S@2z09YF>Z_ovtfq$XYyCQ?7iLSNb*87sp|)3op3aA@ zw?I8HzKAn_4Rky}XL{_Zf6aAdTi|H@A}H-6P;Xa2jo$`3xjb$UH$YwA3AOwn)aP)0 zEw8_qq29Vd&7B3dD#*1P9N|pbOJ57K`X3Bh>Z?zuPXyl3hJoe>fmJ>ecs4MXTiRQ2 z2BRVOF<@Ks!QR?{Eo|U+Fo*u2zX?{k6fCYIFWncQzpJ7A-JlE~)2{;S1CN6Z-T{{L z2>lR_wlVNS;6Y84`4jr1{vcS?pMiJagPQa@jtU+Q(rEba zAM6J4Vi^V7Mg>m@wx=frF933MqGN-5fgNoG{;(sxp&bwP!)$vDzdEM{&jV{`9J&z7 z^+e!F(B~qs^~GTO$LK?VPCL_i!NH*YWprWiNP14N4yeNHm2ss5STkeGRJe|&!PPp2 z?jJk}%6=sre=a=&YFY0m^QgMaFKg?iKfY14v}>3$)mh2ud3tme*!y1E4uPVssx5Wn;C_A8LV}#a!4j7c{#M zobgB~b3Zu$YS4oH%ff244m2i?o?aBX zD0Cw1wq7poeo{J4?F=%F5Q$ z;Mn(vjs-iY0^L;5M?;T=PN45-Pllcf{X4Wyn@67sJsWy1v^Mm7=!MXWp_f80hh7Q2 z8hS1CpU~@}H$rcQ-U_`PdMEU5=)KUo(EFheLLY`c3Vj^H zv_AB8XhZ0Kp>IOphQ14ZAKDoDA@pPDr_j%#UqZizehd8``Xlsb=r4H1j~3R$G#m&A z!=Z3EY=k3WGaLV-77ljvxFA87G|Chk``;H!bef?L}+!|AcG7r+YK}R`~7kGRic(F8n^6)raAa!XJkx>z{@{ z3x6K|FX+4q{NnZDufrR{{|kQ;ULXE0{C#+1_=oV1;h(}khkt>X-@?C#{|NsX{wquj z%~&6%M!*QdI&2t51lCdbj~OM#X2#|qwK29d+8SFKTN~RL+Zx*$+Z#I=I~qF~I~%*e ze|w{Y(b4E+>}qs2x)@!JZpL`Z);)}##woP7(Z}d(^n)#XLfqbvdS8&+gFMjKleRYo z8$*l(i~;mO;~-<0aj-Gm7-1X&>qCvhcy31+qm3htql~{9!pr%L9%~$Dya(RSiN;Ar zsd2KgoQ^fd8RLy(^a;j?bdphFoMKEi769d|jA~=5@uOY?`PUicbh2 z$KI39HvVDEG0rsR8uN_#uwDSm*~U4>ANof49hqlb2*)`a;uk~w-XP86%jL!u#!}-- zo_-mmKNJ2J7}p!ijTJ^GdZW>qUT>^4ZZU2(ZZlRHtBu=@JB&MxyNtVydyIRHHO76$ z{l){3;vwT<;}PRgkRLamFrGA?f|$o)>odkyki%NO-QN1D@tScR&-Y2K(TV!`w_l%U%-mvZ)=?C9?!vEfpeIolt`bYMQd_)IEKBoO6woi0mWRN~AVtY~} zBepNKZFqEq`C^~YqazPOt&fQu8~KU~-|D1DY2;;E7Ga+8XS6)Bo=%KRic~~Cq?038 z(gOVBA>9j+7b7o0Uav%6jl3554@hrB-i*8zc^lU6M&5%w z--nbdAfJyTpF}>5d=~jU^54i8kuM`(Mb<~Yj% z&27wW&F#$X%^l1g&7I7h&0WlPW_z=P+0pD|?rL^6yO>?gZf1A$rpWGQ53{G)%j|9T zG5ebRAm&ae%iiWb=Dy||k^Rg8=0J0hxxdNI=>T)6d7ycaIm|rR9Bz&Pd8B!$c^Jfu zG>?GqBh91CzwyvP<``HXXdZ8#V4i56WR^mF8HC4~K59N@K5jl? zK50H>{@eUN^J()L^I7vbbFKNj`GWbP`4a5+iutPfn%OSWDbgkKrumk+XXG98UGqJ2 zo%z1`f%&2Nk@>OtiD^a}%+H~mUzlG)4(rXYVV`%*Z_IDa@1U$3&7C4Ynm?I8o4=U9 zn!lO9n}3+>+I|6!%i@19g3%A)hu?@sqGmK2wW6`;Msu_1=Fu&pZK7L7+eV)r`@AHqCKOZfNn01mxq;R@8~|! zeWO>I`$ZGw7!rNK92z|^%1Uu?ba-?`^bk1K^KkB?qK8M1fTJ84Jxa;_SjheO=n2s; z&6A>~aD+GE7~`VqQBF~Ee}SLfdvKQZ(dp3{(V5X%a0bttr$fH8d9G(h-v#~5kDe86 zFc(5T=S0tiDPLb5T^3zu{%$lxe*&TokFJQ` z5Pjdg33RqHdOy_gHjyo%B-eo*43FLwy&JaO8(kB zVEg9rnBmd25PAVpv3#zB?eClaiM}5F1ycM9_QT>5d9F!AB%nx{WSVn^z-O{ zqhCb7jD8heAN@MIA^N}QH_>mS-$lQVZjAmA{W1De^yla=(O;v#MSqX}5&bjzSCm+q zrCZbrSV1dfg)PI1Sf&-VEGuS}Sesd!TU%IdtSzm!)>hVU(QT}4t?jJsVV@nXovfX$ zU95Iid#i)h(duOFYIU|gk9LKW-L2iM-K`#0Ppg;J+v;Qe5bbB}VeM({W$kV4W9@78 zxAwCJSOcv=*8bLDYlwA#HPkxLI>;Jk9c&G^M!-==T8CPPS)<^{M_8lbxJSVekB0bT ztTEQHaJ=KK6RZ=hli-MLtTH&_IBUFBZcTtAO|mMiQ>@8Wr8UK>f<32N)2te+)~d7W zt?AYbYbKQcRLJdg>kMl)>^;Xi6H;}y=38f33#_iz*|7awIKuhX1rYyFIKm=pF-R9% zm%!OA0f{YbVSN>sud%MR8m#L;dj~^qH&{2qk#DwETDMrYTDL)7t0Dh8tUIl{th=H7 zeXKQBJLpw?z7h$(p%Qs);rd_)_c}E>wW73>qF}!>ti^^r`BiI=WyIFtS_yvto7E{)&}c;);HF- z)^||8jn)rv^q;JstzV)3e~tcb{bBuS{bi9DbRxxQED#IELNRdqVv(2$-&QOZD~W9u z+dQ^KtW9joSlifEv8`j<#I}uX2dTG!G&{w1j_nd_7i$mucZ_w4vD~`Ey2iReXt&tz zu^zFWv0ky>u|BcBv3{{Vc%C~$x_x8)VUGc^fw4ic{bPecJ^+r*avcV_4v&q99m4a{ zW20h+LtZ^&NAg?-KrXCYERW-3C&W&SodoGmj+OD$J!9pN>JMvDtO8;u$0~VjHN^Ff z)j-S^Jls1r6V8N{w0G=`*zCAOWAozD!uWa%DD?#(_lx~2wkWnZ_LtQ*c1i5g*b*qs z<*_SbOJi5Yu7aGG#jfEczYdPDU2H|{hS-gdmp|(guS+leFC~VJob6)zp*bM*RNvhV_!pA{}=lPwDn!=``E_V z4^ZBov7ezdzs7!x{SI;cU?C-2Lq|U?36um&c7~(1jYUfCk3~zYl2}Pe$z~Zgc3>L%4x&mgsv;H$J^Jd~?q zLIsqvx~8MF*?i!;6))KCKv zaPoYoME-TNrk2Nxz{RTSy3*;@6|BUNd3{YqX~tQh?FbRaDi324y*COsZfSm0^)dBFu^n>K3QZuQ*#BDT5-!)0eYr zgByAos1&5>Wi=H{Y+Urx@#PcB>MOw};PNJAGs@t*refkGu$l4+%(}|qYa)D=jfD#V zu4`WDrIppy?5eM+t0h9+%z*7mhL<%n+f4*Z!LCHX;J$wS)bbjB?UN}LGb>=PsZ%Q} z#>H!!F+n9wEh(*@%B~J}=~dUprN(AgOJt(tO>kxND>u~^Zj8wrpfpgEaC+iWkDrec zE)_)=2%Azpp7W+woDdXQ@=RQdWfhf>#iR<@Qd2eqYP_ZbE>;^nwGaS1m{wm67j4QE z*}iU_CdtO>)->as;{hc#sG-Mm5omzgp^OKho6(WSy013V1No43qKEV zDa$ac@d*_(m57>hM>viqc8MesRaA|u;a5!}sSk2b zDoN`qDnWfRGrMqQRpS$pKt!fQrc5wvGPSG%1P-UfFI5e(FZv{Yi>os^I$_a`FBX#S z@&a`5t3Ek1eo;shOcbV(ZHlrGZn!}II_39Oxx&WQSAhPi)QvpU!pz*g?fNV-AnBNP9a!?6^tg@LOs}@gE9? z8#^NIC)q)HRAzTF5~>rf!Aa${;2tW`6YI-r#;XyvDZL;krmf6{!6RIa0fw+V17p`w^aNhaIc$RSn59U>Q@!d zE-AJAN}VJ&am%i$=Z<7W)pR&fu8Smpz;;w?r$HFJ&d(#{Ep@^(D%u zT;octo!FUH+KQ606nsQ}l`C=b3IO|3q7^%59Ps-E7GMWN<=CM(kL@7j3T$Pb zs2wAkly*q866_EZ5gd*QGHoe`oxK&Tsa$TFF{!+YunUq*t*M>}PA5?>5dKTa{VC;V zPuM9qmIS=4a`N4^M8M1fCr8_$Km3ESyqVrQD@) zJh=bN`(eK$cJ9#RuCA1!+F4V^DnV{)c1owC3z}CO+@N@9=0Ve1W+nA2x(V#23UBH$ zjW{`;h+#ig0Cob6vPl4N`*&sBq_Ub?;c!E%Vp2Ri!hL&EJFcc;YF%kv*+fz?!J+QD z^0J!h2@}LG0sN4F4+Rw&2ln)G5rle8#FSNXvtWK5oD^sr)^#=YlwCjIKH8oP^TnX*xhJETTH{o#9^n_cylNa2rXHGA zpwDt>>4C;%ylh{Jj)Ae&^;P2uct_BN1n!L|yypXa=Xft7Z?M?7;JSCjI0CY2#)J7l zCyZTL@y;^dy5N<}{NHKy;CI0T2Z=7i@zr1^@Po?>%*s?&2?=<^6tZKvL3?x(^sIn3 zW>t+Nl2N7X7fJX`&;?pvR|c1L899j@eUPX-MdL0C z3>q|$3>-)X3>Zje_Zmog3?#b^B;5y+&I8G=ESl^``rAJPP~xfOWp#Tr3iso`6};y& zo}w>YJ8%^xI%Q-$fFa)K79Ff2$G(kn?CVgrohIJ927dSC@~XayAISP_<45R|RF*zW z(JJU=&#K%-_6z~~;b%)6uTPqGnlnv0FV&gK$qVPU_{FStrpgl7S3Q_J>mRiXmbL>_ zrf_sX%GlJE(x*}Hm`t8%%CO%pUiF~NM0Zd6?yp4ZbbVb)iqw5xG6BD!qym+Kq`;Y@ z>q_R39eno5rQ&$vh-%Y0k-6JUpHk!uJHrX3*qY>R%Un}<-Ev!6?^~v@%j9&dQ1_muB4_5 z{B`L(GI8WHU-Ghhe1RX+r!)4HTaSqQzGvAC@Qz&khG+X8apr zM*O?UedK;}54nk~AUBYx7SVcWJ+<966Q1$hS2MI5v_4vi)>rGV_11bRY+(;JXJ7bZ z&o0ts&#C28Fhfv}(m1Scb1M`6{sA@zEStYRu~&rPmB93ipG{2zF|t|Cr?f@Rd*pwI zEy-5#Ot&H1ksZiRWEbTi?ZMF!pI!N?OFYz#uXls*9;6qS*&GXdlD%PW1p;k;LI%SB z{(K7|LttiwgW@uUwatZi6s#B*+Qrth>80`01P$yF>JZu;mi^%AuO}O6G0G53qG1@7 z8jHe{RV=)fn1n?hNu(jGkYk}&jgS*z7LYQS52T#$ zG%>zw1(^)elz1r9syfp~G7aVxsV6hYEEw$Q{G1UF{)3!J=8?0=LI|J3W8 zh7-qU($GNHVAo)G*yl9J@jPt^JT1IWup5NMrvdVApvxfNdGK$?rdl6tb>s6{Y{BNV z0K45HWBRMCtH7=axyqUeW4+n>0qdCUX9!KX{Lx}X-+d2%2Kj$_D|2i zk%kz=l{Rbc?TEzHlukl_foY~#?nhiy)LanrYqL8B zx!jMyc7%QH<+B}Oki=~dFSu}Pmiv^e$sPQ(^WTmj@&1LoY_-PM!e6+DB;Ti810%Nx zjNfXl_bJ&4+WiaTp-rCO{sor17xyW1;eve!la-Yayib|_J|#?fDU<}?xpM(-GiUi^ z^A{e>%7sVx5em(P$5L|PF(?aiL9Oz{_yrb=Tu^nBN^ULV7fg8W!T#jVh3vyTvT@-F z@^5&P&sz9@k-S3wL*9h90<9w-LXkcppTj$VzJ_=Iu+Mk=o51^jeg^5ccqr5A&rBQn z3#S5F7)ENx8jaf6oQK&Pf3}5p0PU=`hj1qz*9G4HLr8b{@4>_30KFAi#Poyr`8W^0 zuQmYQ@I%M}@%V$_4MENnA~cf6j^f{=wZFmo80|RtW`k0i-|xtdf&Kz(rwDDMzmVQv zh$>_3z2L%$TITVNtI5gyDk-$TFjh;|ju;DNL4QG9RpJ}{1yvi_<<{aaScDHJUd3+OK-EH1sj5F?2`g50^#{C33nEdIg-?kx~93D&2; zzuR%pm0FcHRjYv|p#@c%M(W^=oHMmq@}NjnFHUsJ|DsI$o2V%x!O?J z%gyr(SNLh0two|0kZ0 zP)n%Ftc><2_va%z=HdAWLY{)RlN=t+_I$)C@^--dXi3Ssuqd_j`3Uy54?-S-_o>_l z|GyM67r|;&c9d#Iu3p`I8GJq{LQK6Z#$Hu4#pA{z5KX zm=9MZav`B=dmJ=!L9hY2VB1FXxv-h?q;u~6f?baE>ug-e_T1EJvVi|e7rK9eq`V)& z&J+6=)Y?w?3oI7zN2t0Yf*(-tH#&q?lFXny}fc7Neq3R_Vx3PeY)Q718RyQ0wsPNeLi5`Z7a|vs3rXgMTu4$$UZ1mWOA^<1?p!EDI|8|Y z;~kT)0pvomPV(t5Y$azfZOZczTPGK;QB3pwg@2*Hfc`=wt73hP_WX|6?`SJ0pIq3Q zB(Ck^^cNN*7my3K>B}{8L8?Lu`Q*YjWE+`p?p)Yb?wd|%zQ1rWasj!JWM0UHB$ec~ ze_>maxVCfWLLvGWE=4XN7m_XlFFxB|I=Tu8bIkPAsF$txFjfVZgGpWL~S7!zgZ(Rkf_f8k2x z0&=0TS>gSNB#q>Ep7^bWjwJD7clN8QA{{kUm{)L<4N3gRLjHq-nI=UOvkm&0-sPnqxe7e)oyoQXTbVt;byg1u+@bv7@BO$OUXiEQk8>$NM8%{=K!x1$nV^Aw3s5l8!QIF>(R> z9sR=v>|Y>7^WNG{q!V&MYJdrNKf>A1*m&M}hq6dM=Y2(gp?J8kE7?_6H2Mq3g;ej4 zaB@PL3m5Xqh5IbLPuV&C&W9i3YeMG3D23NUOxaZt=ldg^HId)(j-5$onLToWsRI24 zCkG1WFO=YY%A#pUbRk`k3sM8f1uy-D`_W%08ZLAtUFB7Q{sMBrOD=4Q{zB1kp&RK| z)Lg*(l>WIN(GIy#G+gLTx+52)2AuxFnZ)^g#2TIs-$SRWE1&(2*uPLb_ak;AyUA)U z#&!hy3;yvJHbZ}*X#9oU$?nJnsR1S=?nj`%AfBCa-k)$NE3e}huz#U={DmH*hpcGy z7my2H_B-P95yiuWo}{OzT)^ikrTRfopPQPi4TYHNNcMJw6|{m4)Cw-A%i+69cP=7- zHtzzH#PgJ|Scl-eEciSnxtiNVdzjOPkk7-H!&s_k1EYc=c!s$bEcV9>f8oI_&sjgL zJ<6Z7o)|AAo3DwG?DI7dQf;4B%Jno-OX|rCGK-uVf0ElymVUmb**xVO_|A1+7MAxC z_`f`UkRD`dTvAt$YbqD6C2qOEuK5P|XI!|9I;l{lizBc!rR)iDtxXp~RH&3zu?DI9TGTNWh%v|SdYDbR* ztu^=aRAhJa_~^FbIpKlfgF-9#NXA5-Y`o)eI0_r@I1k>mx8htlHpsU1hQ5KpZyD`nH5pd zzd%SA@Il?SBZg~yy#dmYDZd%>SBeJ3>7VcXB@3 z5$s4-Nv3uLOOcrOm5`DWtAxc7;%rBVxK!Vhd5=M2OX_w6ar7??>;x&b}p<%F37rKLhf7` zgItgrRNE9XGK=6Je_>Cur_@EUbKwQ#f~+ehUvHJ_BAQxm^F(G#@VE;lwf#@$}@)!0Y z`$$!J!G%|{+>dw-SinB7$JgwBgq!zAWFOZ=;^Uf%^*wa?AJ@e6D8@D2Wc@vd@s5Rh zK7y4`{kR*~B*rwk8`q@fPCOj%*u3!z+20=_&NJJ%CMOr{aZRIwf5Gni!eW0~f(zN+ zLx)_jwa?ZqJKm8UL2x0ranQ&Gra40L_gBK3gDxBw za(izrazWI*U%0^DTe}}D_6NDZG~ov>JZ^1?#4U5tz{qY*qry=+Zto*)-&FbmDavbIX>^>9a-+F-&@4gmTP`&9e#AP>5A6s-j>v%vt)qY80W16S5z^GjuJFV` zuFqMI4L09jc);pmo)BAOW_v!u`8?$-@u#sfKOga6;`F$*Q;|`CJeN zaZ)T37o77iC?@3kxhZuYCcAlVO6+4lH#L|H77=Xk_;0g}$b-;)E_}jEm4AQXGfm9P z(%kV2$x13#F0hh{`;>&NkGX%Ivbg<)T;^qQ)>W?lf}glBgbb0&@`4Nh&EhY78E2Ks zh4orK=4;B=xF)GSDHJ~!DyydEP}!` zkqb-@x%N8>-KpQj?=QS!eY(lCBajQK?WLA;^B357#{*%pKgb292|sY*aqBbW0=6R@ z++-b&TtF_Q;R1VZY8Wi`#|tiegZ&G(`e9wD{slrV zK`tN{(r|$p_eVV3Umij=rX;5&V&C<>N*&n*l>O_rBA%iTJ$-(oA*`q5mecE-1H&;_zR=R zD5-`badIJm{zBgR7my3m*ztY@s3QHirqN`yR8?_uK@^Yq3nBCu zWL+^K_xlmZg@gjpU&zFTBgv6cRmI5#1N{Z`7o?5a0`@!FnsB$y^?t-rv<{ zX*!N;l68e#$i#(X$T3n=#py4Upudnee*y1DNMpzQl%R_A_bJDaF;Z2<$puk7*6+AE z_B+bDVglZ$O!PV8IB17yBn5KqUpST=EAuFJF0?@|$hu-e?p&CG?FgwsY)54B7mg#x zNlg_e7usSw0^1SNMr{G_N7$Nhx6ajHIG!9YGcHaph~lw!#MbC9$hu-e?*0PyFC-L* z{z4{y;RJGmR8?_uVO#VU&|i=?Y76Ku*qU&+&edNyk(?+qE>13p;xT`L5dz0M%IZRY z0aRg+b;N$hgk7YPa^=EFur;vG3pJdSI^c0{IjL@6niwpQ$1 z*dF}_SyxTt0`@N?6o_2N#D$Z|$x>Ct$%P%Ue*ya!q>b7F_Al6)aJSC29Z^QgWX8qG z1yMZKzrYBA{R^_Xn$V6we<7hg^cOPu3uDPxsjA}S!p`U~eC$=MGT`?i|b_8-Ep+NK(GI61bR7q78 zI~Qs#RT*hkP8lj z$Pmbt3)9JTnOkvkp+EWyINnj(s4d`p(6%Prt#jqV3^GGzT%24G#bf@$0Q47RT`>Xu z1@spj29Y6`)82Sr&^A~U&v@~{{e*sh>dLvWK?|23| zL#nDcxgd(i{DtA@FUY!LLhk+oav`BW^cOO5VK$j9RaKl^Kz|{B&spz}?Feb@$c0Q? z_y_ri)KqbDK@<=Dg?v0`Js7zltsS|Li3@Yc9I2_|R3!~6qKz~8ns4bws zU~9tNI#({tBlBd&#mNOxJmxPPf&PN5D<+`7fc}ERATk7U<-&Y2U*=YvTsRW_1@srB zjoJeG3$`ZQt#jqVS>!C4adC1%6p#4}e?xyk))f=bUqFAsVGtPtxpH9vSs-&OPA>c% z{e`^w3&-GnN@?wQpEA>Z%7tX1)KqbDK@^Yq3uDk|c;| z#RTkM!10a_gUArbl?(qO|B|^CCl@B5zkvRNv{73?f5Fy-yLGNySVR`djEj>CqIk?- zn1udb7F`U|!u+^uuv!bRjFnQ?J) zp%S@(T#zz2$>=R8NaJDZky1qY0y`Jw2HFt+r#{zq=Bx11FZ?F zi!&_J+22D0U4vbN-C-X#9^gD}NN{LypI|puSpI2%yc_5;y@Aeye>*nS`e3VZY^L}O%Kqf9+ zMlO@-kPDkS7wVA<(%R8q$i#)q$>ma0$c0Uv3v-bR(%O*=nYeHTxk73Rxv;5oVIFcp zT03$f6Bm|}M9(;KVN>S<&c7hBfb+6|D#TriRP(Z2Nv@QtLN09TT$qghg0yz@7cz0- zDkAQgGj$;sHgzsMid;Z0NDXA-!qwzznGU(IsdM36zKNb3!6F@ zcENE?$OWl^OkB8zTqDzY!G)>%2r`l!2LFeX(c~y{G&zPGOOA&!ok&Va8F@H9>R25I zU8Cn?95jiKgTA@ZxaRcZ9i^h0BqYXKI^+VcvRvn1U^{uug-4JJ_T`pw?KKw~NP{e2YvIClJ;lga>LaXJ%!N>)9y=4--=E4o+23fq; z!i71=g;vXjQsjcX-ZBYZbKypEqby!);lfVHIsZH--L!H2WL`fAlXfg{*?b z{uCz{MCnw2;rtftcU-6W<2mbX^8UUlR!`ZVv$kz5dEHch0s9@3b(tKKo4@cVSq+Q* z@q!CYnSbHJ7UV*v_f6S)YTCM(=3ltjS_19yO`{!wTySHLxp3io$nbVp>`!aq!oQFU zyvmyXoHcU6w)x!F{%A)qF5Cf&{qcee+3!azj`uH!wY&G$z72hq+1^|0@B5VFu^nNX zeGY4XaDgf0PFU3l{rRoLsmRxqw`- zO;oNETzDAoQ%bF*7joso-Q;eWnHOAWO26Y}*uTK*4Eq-neU3P;NnXY&g13)%Y}Me)?}3s<%v7yL4QVOQ*Tly>i4 z@Jqkr(_{@S_Qwk@G^HJppK;KBz8``2DQ%n2ZS4;(uy(|Ku-G3jxX=`Tp(VNC7k^FQZN4E0zNmjX^eNo`;_tm&LHH{zreD202ce>FD|5RNBG5G zcnAFj+w5~#`^8^)k~|2D{Xs6UclY|^xvB2R1>5X%So?(w|3@Bz#s0JwE?nJ$_aprA z+!P^~!W&pOjdn!hUM0@UVqeM0>s;Fr50i&wCar}F*B}>ooi%;@0<<5I3)1f03x4qz z2zdk+`_o#u(12XvRn{CXe2e23Y_rc{?H?{YN*imuhJ(T(}Xr&}=STg7+h&-Mbh3!-Xfv z6H+a$g$p+$7n;q5FR*_>+P!21iv5n#?%fOi;llrs|C4HIEnHZQTxd2I_CYR4yLT`6hYL@Wr=?n23m2NxzhIxN z-}@Kt!2Si>6mnSmhYQb;XQW<`3rrP0d2Xr%pO27+?^^H=7oH{0O06Ilm@53ig?{KS zNV|70_=gM6k>{jZkPA!|{@}vbaCZWqrn270*OBj+j*y+fvn8eoAAe{mKe`(X;ds={fuZU+|6*v?^hr)MaafagukFV~chXoD`jDmgG zX94eb+&6f5JWNOxNL7J5^{T)F@GnxO{(dB>-!W7ARQ--^W9&>?@>4i2lz~5&{Fxuw z+StZOj?W%bn^H3(c7G+us=(iQ|HA9!b(!g?l(s52w}?<|@2&NVzc3B`g(lc@;kd9c zB^RbOnG3nTSLO}!hSZN2{zB8ZfcGg`rP=-hn}ewV{+GjY8MWtWve%+|8_(Coo{zx$ zl+yHF3Vz^%xKH^ec~j~HxxiH6kNyQV-VwPVP2Z*9A1=H_-jX_LJzV(CMT;kM|3cx% zHEnd1d8yR8DqO__qJQBdjRmeF+4~oo;xC*NA>R%|XcEqX31!?#01^;m2J@TGZ3vz*}!XI3i zi(HU)?_Tf^7uJz=QZ22A3qLyg@Zf#rz610z?GR+&k2bO2 zv6!Bxyg0_rq$NLo;DWeM`967HDiXQCRMArYLUD0nd$@v-3)1vm3jX232jl~(6XXI@ zg+I6uK`uzUcQ5#d3m=jXrCN{+Ocnm%!a8h6NV|70_=gK0k&mQWyx;;pHzm~%LgAj9 zx)Qj6&rPYicOw^$3tm4r^)dNaD#VNDrjQF#{U8*M3)dqTRK>fL{lkS%$R|=K$OWbf ze>`Ws7`Y(r-o4--E__Npm1;pQFje@23s)c)q}{t0{KJLM$Y)Y5UT~pl&spR15vT=07Sh0n?7QY~KeJ0cgP`avk%^OTEmen(aDE@l64;lJd+QYWp4 z3pg(etF-3$3+z2~IRAn)eV2kCxFE(menGyFI%z#zz;*o3WdQZ2{@rizvt*R(|HnF(G$AMr#C-)HTp5LW^JaN#TRmDC7wfvLhDT=)~;Pbux* zz2F}%tS9TGT96A&75?DDP3SL3yLT`6hYMemucca$3rrRM;6kqwY)44LcP;pb3meD= zsg>5l1-u`@Dy=#Fj#uLS2x<531wU{>+>iJl`JYrv>)`_4k6@M794_?7`w`Oa-3xx; zg18^?4f#f@rS)(D=Y3_B)*LSU1Ltv*cJE&B0~f@+uiuhyrCM4K7tmi|mDU_CtVMr8 z+P!E4!}rQa(|0NOfeT{1<1geFsgu^j1suP?Dy>;uz;=YRd-sALxFE(a{7Qb6YC$eA zRrsSFu`O~z+P! zd-sBWxbO%0L#hS2z*ON6E_A{B5z_A63;yB4pX5)e7UTj`g+I7(9{LN??%fOi;lf|! zFR2#f0#k)QxG)X<1!?#01^;k?Xt2aT$OWbde{kV3(a3P{akP8l@ z@CO%;LM}LJ-Ce*xTrf2gx!^Dge{f*}a=}sS?gIYdLR5<)7aT_64=zkaE;wr4UBEwF zurv#~;4lh*aA5{=!BOk(0{-DbOp75G97f>}E}V{BaMZfHfPc79qLm;Q97f>}E}V&6 zaMZfHfPc8KnYI~n!C@5s;KBmrf}_^m1^mN>&9%*u3l5|32N$kJE;wr4UBEwF*h1UF zQ!f0fKd3*fKMMbk>rd+c)}Pj&)z|7T=!CqazoNgU{|*xS{25=rtrH4wM1lWopX!VW zK7jl_(r1uaP7f5eo) zlt2~ykA!7P;49s^h}0|%li0eNOOpb7z!7F~c~;<-c-B>cLm}o+_)aX&uzhr~zKb3f zI4m%V=R(K=ZAfrvaNpqJ@h~A(AXNqK)T;syz`t`}XXsUUV#E2#oZgwXFrmV6;W!wl zp8S~~+1l8~NRH1QQ=3xvB6fcz$Ev{JnW2$3S{uoQQ7LUT`!So7B0xjbpeFoVw1jR> z+t9XjYq~952;0*g>CUuWoB$o->rS*YNL}NhOh?Ylh3=5U?v!z%XQRA&HwtGuM$@UXX6M55f#(A+!vCwVJRj&vor@?VOT#3#evM1d1{rhT=T`83up!Qc z7XuH52zfB1F3zy?oQDVBg5@Ee3nAxoF6|7#PXxZcA-T$%W}2aG^gPK}M3p;Qw$knjA%r zCdZIt$?;IlCz4W9Mh3*MpF#0;1sM#|0r5~KYsk!nX|QWOVO+Rbp1;VgrP>kBvMzN7 zf#JLwfuUZCRh_JjdS2% zoC~`Lr%Nt~cEs)2j&Q0iYskBH#4)_?w$iqeT=1eD(KLVI&_>sCDm7>3!d-Ap+{619 z)->{x{NgX1O}~elzm;q9R(g;07ZyUyLaHv#uv6D<=y|YQ5U-C#oC|vfFO>Bo{DlSR zFF4hfHRPSYAl_TMwYIh70{RQAy8PlVJdXZC)~mB|g2J^Uy!IEi(YBFXXg&VIDEWKT zxaJaJ^cO@wgV0EF|H5P85NOeEM=Womzi?0x{e^_hT)84srpx!0%qB8o#i;w!NoZ z!0`*JaTap?!eucWzo6>gja)c?!Rzr0J7_ydF0`KU3r94&9f9{FzJw8FiTe=`WB-B+ zFcgjpUiUBTsO>1Z;6?vJ)9zCu7nl*-?TDt0YdRab;DQ9sB>v&TPTEeMask^Bs^t~3 z9Wfr;5vuB4$%W&B*X@X%wVfpwupPmS!!P5S&Ov{{6${ivh2w(P?TB5pT_hL0Xh-1v z2-WTi`8?$@ct1i_y(_tJT<~sOlekaWPHQK*;KhB)ru8r2IA~_Z&Ff!SgX5rGu|Q2! zI4*eSFNkr_?X~uj3tspOP2<7=&AuOj&r?1Y#OEp1Yu=6Q2QG-`DLZH#JmmuRJF50r z$bQG4u-{Qty(_tJT=2Tzv7^>ea>0v!$ENi!;B(f@jO}(r)8=b>44<2F#R4@^;ke*k z|AKhVx|7yPa-sF~FJL=DYka&T&f}H|5QXD{*X@YTT4%|H*3*voTeG=<^EK@jV)Hc} z&be@S=%zRqaK5JE;DXofh%Q|aX)8>8Mfc=h{5Rh`4fBc26 zT35*h^cR>h_+`GPUg$5Ry!JCi7LE&E`wQK)ZjuY=FEE?%%RKQt(O<}ffRx(`#|5wZ z7rJZRB^SK#7jRsYYJi2DC;nNyAEBz=m0UP3czr)&H*Gh`h1PRF0{a)388@$gVKn*+ zu2`TZDjXNQ_7`^7c9&deJ^lhdAE9!gY2z2Z#OEW_OWu`SI4*eSFNo(OdT2c)7rgKn znl|1M?^CK=Xxezk1F+xG6${ivh2w(P{f<4go{|e*^gA}Ke*x!-SGmwMf8kl2Ctkhe zUCD*xf_MIcm?yrM)=P513x5H*pc-T$`yC%gE~u(^CHsd9y|vz+askIRsRmid=P6&n z_gSl|cO@5&3tsm-_R;!CE_l)J*fcKS^AXI9n|D8A6+R!~iUn#S|8SwN))%>;R=sb= zHLXT2IO^R^z&~8*r}guc3r*`^!26WUifwauhk597B#J$3tzLNJ>c=84!PRa!`C-K?b{cmXcLw=J(d( zJZ^-rck9@n6_$`1=o)x$>6)OrIK%cHVm&m_HP|)Soxkgpkn{L^?)M3Hi-!qmfZA%H zOW-~C7s9`DUuS4#yab8Z%;^*93Mcu23nO^l?WyhQDHq1TY~=Bb%?J!(assID`6vwl{LY zVG(|Lo|2Hw6weF&1&0x&3HXN#`)K=k$_4CSP))Fq5^g;b${ZaUTTz^vkxBj&LtiD!%0W9_<{T2N+oy|eWK7Yp7Z|g+) zl@r@ie`oGrzGX)V9KL!Mo=p z`t$yU{#t*@1uveDKz~8C;llb0yDEf5e?hH>baLUi;I+T7pSGXmf*1aRS6pEC=iE;x)JO~4QSg5bhHZ6I>NVFmu- z!Z(Vigj{eKL7ISnxG+c?gj{e~fq%GQpuga#`RoDzaAALKf8>J0ApFCH2y($u^VtLb z;lf~TFml0R5dPtUiCl2heD;8UxG+Q;f?RMIgnzgYMJ_mMK6}7FTsS~G0J-2W2>)=w zLM}LJK6}7FTo|eiMJ_lD!arPyAr~AqpFQ9oE*z*Gh+J?OgnzhDf?ROaeD;8UxNwkm zkT1D_^Rf`qMd1RDgU(I`Lj1r5@!ZrfZI~~)fa9PE`B~O{)5klufl<&n4%!VH=P5VJnn!;@t%dY*;ke+nzc4}@A+5s;e*w9mT471F?L;SlW* zX&uM~W)c3mAMul{dE`QR7N}eN!-bLBNNF9&1%Gkj7g_Vj1@-DrFZ+iJhiZpP>p(8} ziwnQXnny0AXMwuKKU_FWJ4{*!a=~9*_(9e@azVZN)64$h!YFN&v<~Egzqs(7ta;=@ zdKRc#{KJLAwZo-#AQ$|_g>PidBNx=GKfUZ9E*zm9A*}5X~NQ3-c}Z zSA;~lI3+M8PzC=ZVVM&6N_Q?IHA}-Jwyuu95AG#}3-}&7p{LB>h2w(P@1Z+dJ6dwV zi}%nW7gS3uEEoQRTu_zoLiP_A{;vHUx!|yf&y=ghu_3R4FH;_+uv}QBlmYz(H`VJO zE*zsBgIsW!gnzj39CE=?^VtLb;ldbg406F?5dPu9Gsp!;&1VnzhYQDQ$08RT2H_tr zyog+I)O_}Uf4Fd*cATeN@M>Nb9M?q18iflut|>be{50?D@!Ii{3to(O#QPDdJr=g# z@lAyb*zc&;Lps?%{=x~`36cw5+^0l;LAAlc&g1ro!Ugmf)OtuK7mf?w&F?72L7%9d zD7oN;zkpm&ZLqLhcoeyyD&K|dA1<7vo#ZJOupObAV`1A7&njHNc7$3F>Eyz3!Rzsk zrCO=vf*0)wu!g0atcEnh1tmFc=BbYt-XI#^3$c1zO zNE7cLE{xO0dCCQRKc#Adg?&HeZweRi{gi4wq>~HB1+U*vIbIttx!}e7DUl1R4HlLQ ze<2rC<-3sm!-aCK9J%1Ih~8`xlotQ=O?i~UazRtdfc}D;D)$c;CTJ6o3l5X;4;OUg zf}`fM2mHf@iP}Wug2N#E!v%_5aMXPEfPc6!Nt@&;7reSp`2n=8KhkHAS>zL?mCY=} zKlda0DQErT$3x*eu{gudtLH9ySm3b0sQ8SL3$!7@p}~EFhsVQ&RDo0# zxI?cB+ynp4eVw6K<0VMMW=@|-S2(F~T=4Eb*{KJJBt;SO>;PaHKH5T@{sUVJnR+aBUE*uxUe$Kj9tCd{9=d77&_~-eEZxw$5 zpQm(z1>zqr)M<5|aslUeRPC{_^E<9oxPbFJs`ZdgE*uxUp5L)vtCw8xVt&UHXek{_ z%i(_#olL9fG+IYz&{M&~J%i4n^XP)OuX|2>eLnpsNQ>j4boEC_rFJo$3T>oBE6JI5 z3FL4&T}+q2zjI6Duybp2Xi-vBd(tr}&ROOjY0f|#TYO*1%e9!7kBRJYmarq=2#NCW zWMi^H$Yi4omdVDTuyb+j0;!x~H=*IuLfoWIPUG&FKZ%n`+I_LLB(l_~F}^lVHa75O zoFNvLbR3+I{hzdJ(MDJ$+lJ?a2Zj#{tq3^_**RXtbCh~2DX~hNsj`I{YkVDl7Ao^z z!;~WuGF_W4YyCwRduPr&_pQt5we&i=9R6>hH_?^!R=SGbPVa;Z;cj{_y^lUXAL7@? zBmA3?$LJGrDf6)^wWl(2f$jZ&8FG3i<+kTi#Jc5zTHYRNAdURIax5nLkqfJ%_r{Jl zbK}BE=A*GRDlMAmLU7?$d0i8d8yD^dLeJ1<$o-qkg?|{oM{-sDi&?nva{THLTv(wo zF07X&PJguKav^=rY|B5D&Bz5s87alazg{U5k#zpT6c_%&SyARQ&Tyq3@7^DpcZ>?Uiy0kqXXm*@@jLio>=-^!%<7c!^Mlvhh_^F#l_Xp?Dg zmNrXr!HfQd*2jhaWVCL#7KvPFtSRJzsuAz{9R(Lo)lNk&s1-s^m-=u-%fK7R1*r={ z&|grLkw?*ME}W*FCa(kZ7g)t+)3wBP-~|`Fn%{94T;0Pd zo8R$}M%TH2#zCuQoOlnN8k=1{BUl4VX}mw-U%Y=|_uzEdzaZv!ydURx%&tmD3h(B3 zJcjo#oS~f|{RJ=Pcl4@%;Vu}{a}S^Qb&WE*hgD62la7kYbD-Gz7uv*o{c`Q=TTIV` z<$^d{7jZ7^8N5)kR`fg0#(u{f?Z<0>VYW6~a={CK;hik^DIbVi7`spT9{lHT{KES* z)A$AV)rj{gv+1gN_bFGWy-)dMbhTxVX==)S%53Fsx$T7*zo3>rxA6;X&wptDkX&eq z`;=Z|K16@PVW|EX z2c6zuIMqUb!C??G(AY!E-CsCUJ5zE2{RO62^cSRgxez+wxF#1`$~}qK{R?xoxsnUT z?k{|d{({56&|g4*!C??G(0qSko;FW%!3%%kQ~Eg-|DVE|EuZrkLWIOZ>~z22-z=6% zpVIa5uvCR2Y@pxJ4fH$yEo2r}|2OblKZP{xh~MyKLp;r=JZHN!Y|W0xvbW<15oHpG z6x)=;^K@$1-qX%Ugq>=`tR*fy>|M%ORAR3sVA90#)!o5|$}}uXN`k@@Hw7#Mad*-V@o>@e8wX z{DM$$p1-{wzi^gzmgIsL;}^W*0=}QpX~>E9);i;}g^q-`*5Z3>vuP>!?OtxZd9RFm^)!_WuOJsxHRetBnhO_b7kJ8r z?BgB9NXIW=1Rx=76kuV-JKAFuo#Pz|VIw4Qykp+XA2TXa4P2;QD7oN85pi6Ts&((i zJ2rLv!UP<@pjKesWUt3B{8Rg<`~& z5;!+Ep9@!MR~0!Iwm>c*7my3i3qMP!`CPbKySm7^AXJe5`;_m~|8p^(I!gt>W*i5d zO-GHbG z!x4?+p#3xs`btyWop6{y5eJHYT+_AMwVrYz`+Z7Lz4>oP5Q6OpcbATL&qoZ1;&ayC zJU7*#H6Rz5#@Px7_bXtk70?$_4Zn)cRCqh_|4 z;U?`S@j9LN-M;hYMy2`U_sPBW}@dK`vx7 z?2Oxy3mMe|8=J$0Ug$4);xF8)-HKeuX4o0GBNsBNr$BxE;BWQ9aG%0wFVT{6dLUl1<0X?TuS*x!;dit*u5b zIF*`X2)U3=VU4Xcb^6rzBM4cHT=0Mkw`;c}7g8Il%UI+>Hbpg$3uVX!54doLc87;t z*ebADHls?~zC}_@;Ul&rTg4B$4cU(DKz1U#D1~TGIw~PTy2L}>_ESxew__ z_9T0geIc|T{11fx{rMI`hLEA;ptzjrIqUVIcp_ZosDV8~9YVXqvR~+?(36d{7!9+` zqTy4l$+2jdEre{PI}aez5OSMw8-JIDb8Dv1%*eLkIpKlfgF-7B9k(+-E+N0N$Li(h z50i;*j&iTOn#In;d4B7H6C*5qNO*8;R`d&FaEy=z7R*fwu_NMT|8ICrcy#>egxsm! zsokeNt39uM*eFMlZ*#xbI?gXSH+*g?StlX}pPNc(X155wS0{4S7E%*L~yR^F` z4+{T2Yk&9)c0HoMU~8f{*17r%eOiIP&{(rg^%w5e?)K1MKrUcAqOm0xE{t4A-;TIP zyGM%#ylO{mO@$j$FxSfj0xJScqs0{RQsj>ux-Ew~x|h4lWyebBoQ4S3}*Y=`X# zyieJJSAOQKkqha$a6hynqJjU@Ueex^enVz$=C(C+JK}TtDYgGU1(_|M^B6*e#6s+d z;#&&?#i}9V5flnzZ1x8*@4FpA|w`Kd5Lck%f2(`&$iop zq)y4UCXQw2C}PRjaT_O*$Pa(%5ItF$P*#EnN z%$ANkh7cjK5IaxtEn?Ys_H(!QNS%^xO&m*2Bl5OO!`Alk?6^c}*cN+9OQ2i8{_h4dTe|QVLWIOZObg;$#Io<~ znz8ptosw-$97|0j^0rIE*7ou2xI}5#7JEtLA@)gx?NrWu#CCgcv5y^M+iaN~AGx4v z6XllIz$4lt9&%x~K#zd^-veZ}?8al@*&;5n5YvMA7P0I*yJqY?Qm15F6US21h`jC6 zu(f?WJ1$Wgw#8l&d5C=yVLO#GAFxD5FxP;(}MUGvFtm$X6!vur(|0b$5PXXyzSDkwS7E0E>Rk`#aHHmjsst4G9VE?h@n(ZXtvR z3Glw|>gwM5cK@??#~*n6-}TOXRn=A1)!j8cvoo_QW%USOYfBwPfv5Yyem5_)Mzgy= z<|FVI|Cc_@3(hT2FH|p5FNU&2y;QwSyh+rS+Sm(!>!$7c^@eFr z=)HgL**j~PoQ+3N|1gydmnqL#vsie}+PU-M=cdt*!Sy9T!_Eu)_TRVvekcdy-@g6d z?Pvc*WiH5sy|6tr?g?E#A5YJ{?$?2*GNZB$`u6Mp^L|o>rQta|_iO(~w=Y)vsG#)* zj7qIhsngTZ(x&|<8*B2Be5PBh@7A$jg}P{q#{K%A5TEJ(tN&}x3-{8q;G@!>k*%|N zH!rk=tnc!|dMO)@?zt#=;XLGpP+FSWw%g4Mts&{Vys&A^3wQcE`!p|X+06?r!=dl; z!a-wny>KpaLMSawZQJeUh1QVtU0&EQ=7qcbU45Dtw(jPImf_HMd10P0nitMOP6(x? zscpO6ywDnwzRL?M#=LO1zq?QK!nWPK&@vqQE-#!GE@9wr*mGB8M&>i<+pqtxkP|`~ zR?Ti+XpK(a<%P9kUbx5K(}#Is`~Qc}O@-dq_dDXcYxlXS*6HxA?k||Hr;XVA9nb#` zzOP9Fs_%DnZbaYjc(1<~dEvO`BmRY)A4X^A4EwpM|Bvr$3eoN6h0!_2MpaigFZBLA z<$eCXm>2ryy|4ctpR?}fg;AZyqq|-=FZ7-l?#H{D!g`@^p0ob{_+FN7UKri;dsOvx z^Fr@=;Q_oOKIDbIdXL-i`*g?n&H9eD{BtgBo!hzIwby^U*SkYTK4lyB?LV=*d)6Il z1lgclEOhd$cTOkiQKzw;Vc*v@>UM0+>Bq>KWUGypTF%f{t8Q&<3cPytBmDcw-_&+r zQ)|uc{I{^r+L=&i6AfoY>6^qdr8&aLtGOL!&gmAN0?TQa#(8@9ueowqrzo zZ%Son*PZTl#~g{i+$rY~&W*_LO=)jiAS z&HZuxlUmA;u?_!z5-HBfUO=IadEr~MBwQddFN8PJlIzEABN6K#3YKRH_F zxBB+fNNPK*9#Ts=4BPN;NTlF6688cMy5&=-;ZyDPzSSC?B?7nDYLyY)>P^@lfD-b8 z(uy~sUb``UKp#J7e+X6Px+CZ$-`Ft+(_ny zVQUNb9*RV{15hZ#I*$lIcKhR>J#Cx?nI*sjoJ9%Nu-v`|qk=3fl;{A@!$$ikRyzYKqN8p)JzMuJxZz(Ux z`XC%Zf>rD$6y=&9TzFi$zDLAmGUXn@HzaJYmLs5fm>{~%7||DCTveYIXU_!)Z$I3*X~P@ zYSkEIgr@X%36WRZqBkIs{C4t!_4)gQ^!md0r$uAFCC~ZMdqrU6w4GL;K{IIhEk0|c zYYboK$V&V&`*2QuUVUMGN&VYQaqf!x>K4>V_jUE}lf+H+t@Z8o9YA-Y+=Fs|;yhG8 zT0fEYhm{xJ&u<;-WT{K*Jp#w1cUpFmkY^tT^xI{eUB?~JFZ^@vO1f_OeSSXTdH;Mm zAJA>5D2+O8zG1{3zh>|qeLmup9FUQ@uPImRJ~vfD(T988ywLl7O)up4xAjF{;6d?p z{apQG{Yw2Bj*~;{x9WGX{U9DQKd9wjz(V1=1%FU~1euTGr|!!()D1k<@KM$+)bQE6 z1@%BJ6+KEB{#GpyTaq;oYrVjl_NeSX=67*70>h8Mi~hxY{jlr}zuxGP_^#du-CZw? zp8oG!E#37(@9Tw^ygpyu7wd)Z>T^@wywJBZdh}TD=7rw#!pmNti|C8I!2P?v+t6+7 zHg$u+*xYUDw#N38xYqxqmVW^Yh3gjlN&P8gK8>HcFWXQz@KnR6S+`KbXYUr&1GQB2 zC}sFtwLEM|*4#ah7E_ajF4kRD-u-StB6>xI90eIH9- ztQWqkzaP;(j~L;}_g^g7%?rKfg;)KnefT})clG^_-MsK$Jl#jwwQgSMJukfG^*v2} zv0fOFF8n-R1Ngj_f6j&Nu+XNs5m?8sOTGEJf1N1o(~{`H>>M}H7!$dt_=#DC6(t#bnt7OMRm*qj#Jf%q5bVcY&sS~)Q44pK8j*_rXF7B~(8 z2gy$K(M@AJA>_d@Zn|sv>+c4%pzqr5YPfqa{C-6D`H26T?dGTF*vdw&BjR zK~Z8*Gi*bdGvaxh^Y{91!REq{UaYwwJ_q5m)4%znmIc%2g3YCptXQ)?wj!y~N*R^? z*_xf(tyF1k(fobP3#E16oxSzG#YDVvhx^j{>oNcSh1T{TRc#gDzks*g z#P_(h^1Azd9f3FfsJ=(x>(P==mTRuil(HPQ;ol08;+*US6k;TwLJgn8kDJ!$EE%}P zR;!HYR&P3Oi#MTOyDyKE zy2e=ENFbD9trxoQYZ|rQ__o&z^1i0-dSTRhYs}VqYn0#LI(pU%1M8`3DFd+$|E7u* zTv?2J0fh+2r%=P^@S~zNI!gv_vDGRgy49Ob+u}{A*X~QG)2cDZ2ukmc3(oBR*gYMXi9IF5P7vNdIJ*4ZeFnQ?4mIpfp`2neVP|mZLZ#wvMRRW z-|CU#oa_Y@Vj!PF4WGl0i`M8Y8Mwt(tBmMYZ#r#@H=$m;FQHDW#vmg!rMF9nyxJDM z0f}TcFW7i?(U^|FyZ+ri%?oQb*KSH#6Wj1_?MQJ>_5unqkWZn8&*8^KYjlg32Fclg+zNi9a;nVOscill-lO z*P{B<)A-#<_*voDB>!jXzk|vCA4&c!8ZU#Wzn>%i^Mp?!do$Abf0E>XP4PZi;+xwu zH}%gwF+TdjV&52)BzfM5g!ZG#Wwq{Lu@ki+za>3|{}j!;W{gv|+w5%DC%WoUoaBvu@5JfG5^Ig9qGuM9qGuQ9qGuU9qGuY9qCxdbfhEScBCWk zcBCW!cBCT@ccf!I(vgll-I0!b-Ab=}$%Baw(fH>H<7!bHf;wNFTSMfuf?JgEZFHPi zB}!&-x0~n_bNF11jvI`Z68%|zfXHW@)&UtGME1U<bQ0{!#2Fd0)+8af5Jev2$|VDe;!OGYWo%{P`W>+l)Qu{zd++A~?tEKO{eI

{x z8I$w1bJvpm6ts>wocPgP7>eod0O2ci7g7A@rghWB#Bb1eoIh$R{{Dm3F*V7rO7efD zcs;jbvZ-w^&E!e0=6 zmGC=+rzU&yM0^?F&y)NMgij%SD&Z3epG5dv!sijbl<;MQ<(Gwuzt<4|I>KKQUPJmL z&f@U#JDTqs6F!XM^%m*dfbcPdPoeR%4)M3A`SEjO-&bEmPqn?iVKLrNK=nU1`P2KQ zC_hh3?ODr=Pw!_S`F|UI&P_`8ZlLzb??7dLt6+bzoG*PH@FoQ}1KzpdC|~lcZv_6D zg&*sF7uiXB>Qv4RC{yB;GU($Gbnd0*Z z;j?M{d`$dtslRp!t)cJmGFX+ z@1xh@V;^e&=aCexEK1X zz0hCl#qI^Y(9h~c&s1?9w6|+&p{J-6|KI3E|Il9OSI3sN$LIK{x!vw2z3BO=>0kAy zz5e@=r1P|Qxgqg;t@ipC(7c%>`lI@Ao=AC3`nm8EPW|hg^mhs)sM5~`OaB%u{aW-% ze-uhP9Ljqf z|7j@x%f-kReOFRmoS5*cgx@AC^S!j^8|nXS;J0zF@c%{phWMBI+gJUKyy7zcZxsJk zF4vo$>Lt0%7hJ|G>B;{7hx{9h;`c1&!Rd%UKH;tCI5{ryzao1N(K`DB;*Ur5uM&T< z|Krke^l{R6Ey)iy{&|0a#5d{l72yWs)L$Cs2KAqRC~8XTupUo15qx!~{08v}J9i(&V=9_oOPcsNmvCyYb4v?9;|&NuDE*cBA5;JRhVU;){tLoilKjJj zA0fPLv|Q%jc7n4%+fn-#BmNgO-_MZonCl--?VVcUnfX%^{+o=)%s<48PhVdk_H+Mz zB{<7_8s7;gzHcOXtzX&tUa|6<$)48tVO@l;Oq8!U+nMyR7YcgY==}Yf%Hw{aAg}Sv zdT`%RM>_5w>PW|ZL>=k4pQt09zrRy|`1?Dh^Y?2?$NfSb_2WLFj`Z>9`##l!`-VEo zPuuUPp#7YJXmzujOwksCRQ4c?4` zGhtQYuSWdUiN6N%Ol=eah!2$~rw&P>RgY1vWMc+dnQMq5z_*VLlX+9`@|47ezeK?I~6Ox zLG=|YzaqY3<$F4wFs{CilBJ&oJG!sbtDNdh80Rl$z3M&bOSny+%Bj9ANBXMQBz`KV zICZqIUL}6QnJ;fGN)Y2SVdeWjMa`M7Sow`dEkEHLuY_@5Z>*8~xq4G@_B&zKTfI*F zgfssQ;wPN>4?^=SA(h8JoVN?k{B%ED<|nND#uHLc`3dLwkg(oIQQ9l@lwR8VPSl*` zD#5Ye!AWKj|0Jh&vmE*zLUj@>^KPn0(fQ~7#R(?`ZvTke=cBEc+m+|J@Uy?erL)~l z<2pCj&w20R*w}0@)6eTAA0FFFK0HqHVTuR7OObYKv)!B&hh2!jEAe+D{_cc(J8s+| z#|`bT#$`sYSFHSs_=NR1)Skz+za-8%eqQrY<@S|Rl>^ew;1YgU+gP3{2ho7ocPYo755Z--!C>Lw@0z+ z0}i{b{D_rb-G{x&3SY7E`v-sbE_}txhyKuKt@DY`JdJuTCbYh>Q$Wi_InCnC9M29*j=>PRjmAq z{8p^|dR}W^vGS|AEMIZvk4^l9mER2gx=Qg+apF5SN8F1_u;&}&VRxn?uUPdp7AJnf znNRU-B%Jx_dyHhzH|+NszCrO;oa<9O8wqDV#j8QsH>2fb9_?iOzVOw*^b}$q_f>7{ zD^~eRGGBr?9tzImFdq+phhVp!hwHiwbo^y|p7beJd;TqvkDsVl$^G-WzGCGk`Rq?# zmyz8{*5joenx{pPuV}rU?R{sE4nQs66_mqdfYj zBb~30s2;gKlH=}W4=U355?tCR_qoP#1)*H85_;(`mE-D*sR=l)VU_m|SSzm(4XrF8BurE`BNo%`$E*j1&!5>5o4-ab|M?})teE9!5> zTETs3=W|8#IpH!sF!6n}5_}RE5N-$loE0uVYyxK{}ahI+SC3865UTf_u&h^N@D*2~; z|76-b#~inOqGvk^Xa93Oe*SkF(?7URN^r3kRcimkj$q|im&d)#SDg7*5I^C}zmoU~ zXZ}^hPdM|bzpI2Z{~D?iblf);!N>7mhr@^OD? z?6QKT9omo1{d+*DP%!(Q^hK@VL;NlBe-(c+|1R-6323|3kM{P6{dT(OZKsR=Vqezj zk`2T0BApN9>+$J2c&=d2i*T(W_FrZ@iF?5m?~2Av!foRw(`npfI*pr5r}!s&jzgBC zag*sZZZe(QVf)orcHH>tZ!rXU9wdxzmghTDfK<*ov=g-Ar_^_DPrBZybhH!lNezxq z$zB>qisN|esQ2q$^nMfRWxOvGO{g8b@mg>uY)Di0?mNcLrT$3@e7-Is^P_!yr}n9Q z9L8 z(fG-98Yh`f<0R+P@q5Xqh$CWK;-Y!;oL=%C;@D9haqLJxjINKU{=@0}p0Q&Om$+RN zBa!{e^X!OT=F^wb4>``wX4ozIW|sLKtpv_2g2Qh76TO-3lDW&_C|A$7MZPUu3zvslE46dqqC$$>XOty2PVhKJ`bk zTaKsrz6i83&b8msuYn$#g1;hvMla(Hc00>{mM#dX>R{yqk9Om=ILwllJl6P*q zxR;@uMsOx}wtls(a$@mK{;E(I;Jo3qp;-C1X_H(}`IknqP7kk=l)vI=#n{GVuBf5ieGO5H( zE4bg#__p6aI(JE|n8n@6GCxEeKGS^{8Lv+BV-2Ib7s%$r5 z9Us|FqUUh(*yk>xU@&G-WQ^NIX9lM@7(+`|CM@jA6I;f zDQp$`tI0C%XT+ZB^VP%D9|>naA0d9i%J+xIy#%2*VdXdI`IE-%|jn+qRBs%V&#a?>A&BVB*cxGT>p;`E;@+Hi9jC}0o@#)Oy?p%5 z>lTTdbH5+XdU=khHy@wd>Mv~1*YbK-^yc}S>7uWl&U)^a`I4?L7kNuBep$NSHyWLX zCZF#o9QO5UU(tM2oa0aVyQ2JEasDQKjf7QSLyoTr;(A}g%J=rYpkA@^>rW+4I=>Yw zzxfb2>xCf@|GZ-5H|_#`w!&AeeE*u%lj?|L!kPa%@e@{lMSR7X|GuqXC9M3$Y;i9^ z#3y0pSC3Qugfss!;wP+p|5wXbocWk%_)8G&Pgwc&zbs#I=F|G1PB`=F_+HcTy>V8Q zOyX#N!nyt@WIti$$N3Y#dK5Xung6D(?-S1ai-@1F@@tw8ik07__A6GteT?Z3_XS0}9Xs}C$+vGSYbzhdQA_oF`UkBwR|4iqcDN%j>hzxs&mC#?J?u1C6+ zihjk)ufC!Bf=iy4`&@8OGp(1Dj`Mx!sG|9;{pto(lDzv9d%|ND{u z{tu)-VXg1)Ab!G`|E_JnPdM}Mr1}Xfzq-`cSFC)0vE?hye0;BgzXTD#gfsuQ#7|iH z4O(9)R=&T5>L;xH>JH0SocVtte!|Lc+zEc``XpiHd%2#TAlfImjC(mBY0E#g<_XSA zdL3kmcpW0=m2})}yDu!$<@vxYpRV6Hhv#VET%qfA4|%>O`&J&wHy! zW0P~c6E1dy@7$j#|0^B8rx5&#(GSNprQ>%KjK6w5zq1@)l0jeTc{-ji0xglD?bZ1G zQ_-vE?YmR`G|$rdxyTb;?df%tbbTeuGhOAYH1DhFBPGidUH$geGT5y!eo{c(g>gr5 zJKsL9hzQv0RE^Y*bbTk=XL_>d{S|S~r|UaezE`@O$2fOc9H;81bH5$V`P?qe(6B~o zCV#)--0b#zPV;?_+{cmqV!F0N^M9LsiigrwUh{E3($DlPpY*iJ_d?I-ozm{?f2LD= zb$!|-f0(ZR=z6{;d7>wAjIVp`xKf<^<89&#E`AGkj^3x`d!y_53i+4MV-h{LC&jU? zJw#V|T`#xAE6FE%Zhs@Z2MH-j>nEJsm)BV|PTSUD!dJb>k8xaQJ$e0=a^$LE?_~YCU<2qUW!S`gwj&pp! zP`VE#E8KzPcOrbgD+7`6cq|p7(bde-xK`vL46%$+kc9 z`9d{Tm>@;pOEg~+j#S9`cZhGXb6XgH@Vy3Md%vakuadrmBQ<>7K>66--{}3zQBwPt zF|Osu<49@W-$>qKJdaKO;`%uLO8r-;zQuU25!GLoFxDMGpDJ`XjvJir7t8#msr`=% z4wdld{d;K}Hw6m>zT4I1eSts`|WV!r37|;LP?D%fWD`^}j#rplVbEpSe z)}PmFHV^rRT}LR+^=h3j>{nXH=LSs{c)( zua3Jqt`(Q|>AH6zS+{2YwEx6jZg)+XSDbD=miJ!3Yo5WYFe7~%%uUPrb z6)az|@*Ct|!a44Fyi(lr{af;!sE#||Ab%6i`f^@N`qYp7ocSfO2eLlDob^B9tS=wm zNnd_H5$WrpcqmpsYT_qcDL>C^8V3!kr&#M%)DFeU???3$&UW*4798hMC%3=S`G#@O zO80vt%@4(Sk@aM{JQtYtWICQJ4&y%dLdYko2mOq{q%_kNJ9n6!FZGbbk~n4i>HZJA zS5xvsRv^y{waaa1+m-VX)~l$S{mgWn_XK*#~Z#skL@pbf5L<5 zc(Wtnv*Wt5)ZfzZedCAGv*aGW$4giV?$<^h_iYmXIqBb8&LeaE-3gy$cM+kJJRv~R?v04cu(sP#gK{f&)*pL5=6a( zm0weQ6f3_Uj_+>SU{drcR({X=*ju>p6)V57b=*r3<2PaD_iSnTij_YW@f9n-Udz^3 zto+7>;-j@&U|Wjzl1Y? zow%2v^ZgQ5eq$TUSFHTz=9aHm`8C;Bto$B|n_}hH8(=TK5>?`_IP=MVov`xzg*Y$Y z5}$;X-wfk!>cUs7{GMQc?!s5B{F?kvxb*8mNs{`tL2*%>^#;EtD0b_F4Sz!711mp{ zgQW{!vGSw7i3(q_@?#tZ7QW)l4{@2Ig`cqUqrDXhU$OEVp&#NU4e3|K%J)yiy#&#& zgq2^1`V$xZik07_d81hQF~7`P>MPFtpntv=e!|Lc(!5ce`Jun2DfMIgfR*1r$IAkRuUPpp{w?(tD?iSscq@*~ zPsN!Z?6=Opgq0uX(}FGb10PuVp4zWi`7vG_mHLX6AIHO7g|Aro{ery}3tzGFd#L{u zD?iTH=}UdZhCc)Gft4TIzfj>TR({ksW8o{#{4joh(85nR^J)G!6IOmdnjeh)!BH~% zOW3*p$aV9i&$-hDr}2j0^`i5&>yxA$=khw&E1l2#lrHCeYQ`t|a{N>|IS*{74&ZYO*1Y-RAn(FCs`sZ}rccUn+adK`;!Yc@lpRngekJ|O=IhRs@W2*ln z!pjq0nEGKqIxqZ&_|Fi2op3+8J~xE){aMzZsXcg(g5pt8{T{+ck-iJ*yzFS=pF;ef z5&vT1-$Lyu2YVCH{fLKaTjD5dV1MZ%XH>ClG&I;-5(Tor!-E@h2erClmie zipRdh|AP3Z5Pvpv-s{{E#9xB=`w)L|;?GF^aSGvk3BN%26T&wWo|VSeIK-cZ@Jxgs zBm6btDM|lqgy$qYi0UsucoD*j5?+V!MuayZyeZ)y5k8Rm=PWaR+TU9(@2fBQ`6Q&O zkgd}97ir%6>X4YiN*=pia3bLS{)DHBxabwE&q1VW$d4?i_U-%YolAK*`$Na8%3^$9 zA0Nd>rB93ICAr_|#s!R|0>fy?8%_!FVr(!RH3pB7YX)l?lHtc_>m*FTFRk*gK!{ z;3kw;_N4m%5&v_5XSV!?<@<#5c+BtL7)P$hCOzf72N%Q1mUTpyKU?l!Y?H_M2=Z<8 zrR4n^ZS>vce)l%|9&*3C#;Ng5l+ZYN#?{4E6Z1`{O0tQuQ>6Y zJ0<#)<5!VB#i~#5Z_M>C75y1sW9Er(P9uDcv*IN0tFtX%an|>u8Rx!-+M`(Y^^iTq znNRWTNm%)ffpITETsKWP^OJrRa97B@QhrVL6)Qj8->UI;ZgYG5sVV-7bA7g7oA@~Q zf%T^!wO6s~Yt9(=62$YF2`j%QzGAK5_K)8umG&HN@|15-eZ{I@pTAb@X*?*-{9nes z1TilYR(?(6LviL)JZkFyCdFT|8g$piy$s#0bl$XxX}@!8$#F4_e|=9%seh*FFFgB4 z^0%41?c67%e?yX=NybCAw=(Hpf#mJ|mCpT>;0&?{+iK5sXrB+Z!JRj3-LeKKiS$#_syz4->~`2H!d;$IJX?> zpWR@e?w8K`{A5)B5+jfI0uo-)VBe&8_{ohvpYE&9_9|UR$^h`y)JER9uO#1VKK6e$ ze7u*%;+o=7OFYVPZb+2Z`+l+?eiEa{xnG)b<$LxKzWSj!Y4g=baWC6RIO+i>+o{A( zL+hpcO!U1xZGP2cH{oLEm81#p^}}8}9q+p`_9u?=>JRMEeBGYbg|pE39U$W|&(|-_ z@z^=WbJF~uitdm3!qoTGhta>%4#CmSmUiGiXEQD`jA$a4fXOd@#5B5s?EM5CW<=f>DzmD}0N6@vtbNd?qyq`7NFZ@R+ z&wM2Esb9Un&&V@&?scOd?@=LrI}?6}@C#JGj(McC_t|Ja_AB><9!ap_tg|JBDww5lo984=KC4t{z#R>`&Q!!DfmUfY24uV%E<1L zaebZhUE6)8tbb2x*Yd`1{8kY0A0_^R278a^%J5hGeOLUA)Uf*|<)5c04uWz2j{M$3 zs)zU7q&>tLdnIm4N4yRF=_HT#U{C$=mC#Fll|#Ea)<^qV>osaNv2xU_^_=^OId5|A;dtCAdR|O^>?(f5s0aTnUG*uwy?%f4V{Pbd zBY?{U9Yh*R>;xdUiCeJD8VLmZ7fbim*r`5Erf}THUbd6y*^h+V>*06fTkHAl zV-?lo+(#xadcTA4V=RI_mfwZ^Jw$MlckWc_&s_iK#-8^UJNGQ*&6f!eCHxNIhX_AT z_z8o36~<@lbDsB@e1v<1Xq_+z;a#cy(-MC|!jlo6obc3y2S%LdS-$U-^YHSfU3iBC z;W-J<^AcW&@WO;=r0eoMW**}?QsU$Hlkr!^9exMd;H@aGKQ-9@luRAw8d)cKND`c8gxY&fOyS>jkIrr*hd&^<30j>Iru44a)OM z|B20;)wZaQaVhGdKVc=fyW@JM=zl(O?jk)xZKD)yFU1Bj+LLh7FBr#($W?ypapPu_mz-P9j)%tav1;-6J@V%TmgKcCFI zR3Cj{{Pp#AP!*RbQ6l4Ppuh3gR~H%oa4#O^s|gJDwUzgcy{JCs5&qO1^L@RW$S40Z z)(UP)V-M?H!uy&2@>R00`V?n<2OD|kUL^by;XyR6<}lbd$bZGz-j9twU)gc&8)2Tb z0iaU{!n8d>uZC>eq1ugh_zvVbJV2s&MVgV`fG?!xRJ(3 zmY4NxcF!$N<6HPSpXv46YJXIjs?6JjV`HG(vs|{9uD2$G-V<(w`OzBxgjHUTGpet; zA@1dPFs_52%a!r2IP2Rx?j?vknXvNfeGMPK*=gqw@x7P)ulk((nBtlEs=xXo?&bI< z9M2!X(RSf?YfL+xdqHrDgL6Y^9d!`p!9(LXE&X$P^57EdUp;Q5Cnny9nXnSv=cfJ6 zU1{=FxF3Qp1e;%qom8tI=++Q;pf0^&StOs)Q+!Zz+ z%1;8mN%2vv{A!%Ir~15NCAfjqzBdHt_H9M&+rYN3rtzvc>z~Q^k9CH@zT)%L-&=kU zwNG)@{|t?@S8e?U)mNPAdp}X!E92uLYVRvnpQrXRuJ$ncJYkGa`aW$ddp!2PH}S{& zYfb<7>O!kOUiT{F+xx)BBcf3%&~G#H$QLHRJ7?#UudlcE6=!`n8-JX8+hFl;{9?aJ z>kGwM-+9<;^>-!m_YCs)VQViQ4_nriinIQUjeh5*H2J~j>xNM+@(bmA#{OR8AKu?$ zFy8G;`sF%jatCoqI1zkJ$9Kk6>JOD?+@$q|VwG>w_bV|zE$eK>Dqn4iJ={uRaLf3L z>xb6kVOU?ZVE>`*AI4Q9_GdZ12*!Jg?DdSA)-8&&U-mkLujo2OMf@1omUWC`)z`cv z?&Wqj)4D|Y)s4cJVS?i_VgHP+--gq?P4%5SM&^CSpUS!|JmB;bRU|%f- z`6Y|KO4^a*RsA#Sb1q%4OYZwbSH0fLb?A&6LGS8$oroM6$4hC?mq{M0y{s3Dy-!TPI*0el;ZOa;yZa3GUap_V z!5-yge3ko^rX~4weiW3(zcp!`?MLI_g6LYY|8cBUaC)9OH{cI8&hdB(|I=|d$6t@L zkzS5>&i#w@e?`{=YSSL)Hi|=~__M5upKq}L|1tW#pOD(u&tTuM`5eFRV&dh!Tu)Z} zjIn+;^A_LtTKjGI?~$M5RMlxJ93=05Npbdxp6y0ITgS;)HV&TS@PzmgKf}kPW?cJz zi^9_OdEEJi_?7Kd|Bjv%KLtDYnYk|JtHCCo$h%@UwFB2#?Rcw~24~Thc{>sH_sUk@ zA4&QrC;cDTc2!p1_YdvdyQQ7M{><6F_j?-sZ8#q9<1LuU?q5lsa5LCjCELUE(o!#e zhW@kjE91m>?mcsy@ct&UN4VO;@~f93F8wAL&y&D-89%;p6D%&0{gm;rL&o^NRs4?H z!tNC^Pa`#a%thC$?K&LKF<8IqkT+*<`Cbu=qWFh=+v-;(bRCDzh4o)_UBumIF+RC{ z`97y@X&f}8{w!AsMt-IHV14pqLGnZB#gB!|e8U(bd?e+uRn76&*K4C4t=DUZ(zu^P z);qDap{buozcO@h+4lMKB`#S&e*e1oyR=y!;l4JTx2yM3O|%1hTF)nXR_i{H@t6ry zn07fQ&n0Pn=awb@Rc1b8?M&_dm$_fZS8{wS{r2l*`32J+UkSa~T{n)8f|nyd){Fe2 z_wA(jN;@wqp%**T?Z-2eM&38VxWV~DR(Ki3 zb3bF>xy5K4O-c3^BfJmEuSopgPd+{@TEG+(Hyg2!Xd4)gq-&ebczTBSe%zbHi zZxs2nbJVQ$@%)b&2YBv+=G_IP?_k2alfFF&FKXKFE4$wF)d0#Xg7KY5JZUWB>tAT$ z8qkgP4))Z4UkP0?em|J(Z$<6)y4pKCJ7h{=S6m`7!R_i}SDeId;l_yG8%i zFJB2g<7juCY*+kPH)A{-F8v&>hmZLQPfGo8J>`{6$nQ-FuT6P_^WTq2et*LE(L6qr z#^K(k-w{_6cU<2keLs!3#8JQZgq@cDcJ3^)bDW(IO?zDM5tsSyy`3+<+L82~MDy)x zgMHPH#;ai5Ct}u{&Mi*uA587tjPM#HzYWD}bCSP;@S0SA3*pDl@F62FHa60pk^ay8 zXK6gx-;KcccqY#HPQmym_cfH`v9CUerb>Sb#(Rb0;!o#+b9b8fI=2`3afY#jcl8rq zobVyBMMeLi2Kxq|zZ?+TRs8Hp^YAj zZf%m^oQ@~!2tR5GA5E#B@#8elUW_;@flT{zSdY*+`X%`@HRatMqN*}}zmD>8U5Gu6 zo3Dhf7;!fJkN3FKc-@iOxhvrlVhfAD6C+NOC%4PFPs!g+Odj!mCu-kN(z`SHHJurk zzK7Rymy`S{r0-P1;k>QH3D@f=F25tp>*Uj@{^^9zrS_dc{Iv*gNO*l3f0LN@`RbFX zzx2Ogyf4_yBPca-!#a=b>_d1$lD~@h8<1a168?hLBdIPKwk9qj3NRJvmPZieWMtq31?m~n`BL_I}*A{w_RkY8IOAw;}!)vFSzs zMij64X`KC#>~Bo+%aZ)AWdBCO(~|s+iyi>;b zy(rQ@w&3Vh`1nBl%XnE?CuF>wSvQEiU0U>iO#Sr_gGGMVEH8MsjOAE_GsQS6!Z>?5 z?cw)ju&4c~bj5ft3LS4YG5zMfd@oS+{v+wd_l8EV(2L$pqn=#P_i`Se=%wC|jD5Uc zp74#P-<&%;`cvv}Ch|G%kI}qoP|f6#v`8cy+yIR1^M|a@hkb^ z8wZh}*F=ui_dQ|!?NRzE;yp9Qdt8iuk>9I@zm?%Tw>9B&X#Af`_(F=yHm1I>HY5MH zHGHgd32#q$2f|a5y&Z|alfk}Uh|fMP?Va85@jeB@yAocJ?CnPU-3i<4$XHjI{z6}o z{5r(nllXf@oR25^yn99K%!XVi)p6n6Hzp6DohFaqc~LrU9ckL>D_*b6MR|I0>etE4 zbzR@wkNE4;aUuO~Nt6m9IE>`ebNZS8Pm0rSg!eSqSNwg>V58qxe>C#A-;?m2CU4{S zKx6%qm!!UPkC?b2lbX2u#st=GV|Rn`yAou_-v8zOF-G3kn*!sMEmD!6>y5CtObZVD zn7U(o(9hCu3E}+-#$R8ZAo58co(GGPS$`GIOUn1KIFB`aT&FPWc<;Y7d|zK+^!w^Z z7RT?Wa7f7ZWB6L|)kZ#icN_kS{2~#z_sdJBoz9(1ah7(s*ISb6ElJ}x-4~er^*tf} z+k})K|GfVb`Fp<6=X=`bg_&2rF@vcu*Zo#&Y46TP9{0;9yJ~-?SiiJOFs`>#UOCUy z!}l~)PsjI$)_=d6@z1$m8@;}9zVO8zd`?5_nK?|JaPC@@mwYAumj31Ie{UOq@V%G8 zzDn~Y+aI6o*J3~O2bl4T_i9jlA0z&UroA|iikgbQzaTu0$+Nye^SQz8o!+zu*V~MJ z?>TRcL;W$1i6`Pi{;WcHVS|0YFrIgB8E>x{e|$e4zk8Yb;XBjtSK`6<+e}OTE^gxE z+$>c88YAx;{2b$9w642=>i@*lcWzeV&rbL&!ap_n+_^Q0zX0Lw3GYDoFv5ou=KJ(c zBL2yQKP3Es!MKj!|wt!s{Vcvit2$9yy0 z*B7;i#{WG=p!Ca@lttDXH9<^_7!qNSfadWSU53U{@jA>eIR)vY7HNY z(D+-7j@t)O{R0VaLGy48s{aF$pUC*@8$2)1r1nom^`|2|J>gji48_q!f?ryO6 zrx|~pTgve9&TN_=(-5A8>OVyOd}8_&d6e3}3E};XeNX4F&aFWGzdYfk%zVTa z)1SU^H2HrL`SY5QcWxcx4<@`k;pb_5PfGEbgz)5q?QzvtoG;EI`7;ThZLn|fab`#I zcL%~d5uTLVa~$!HCVV{M9Zml_H$JVCH>7xaUOOx}fI#v;paRo&5iWt>0Xj z^wW8k=kNV08eenL^}sz%dwtX9fBfDf#phY$k8^)B80&iS?+MetI8QS6@Es}P8EAei zM0jF~&tIs0Pm#VC4Bz`3$iKZv{(9=q7_OG%+eDPF8>DYv$|t82o{jt;NcKN9@x(fb z{CU8%2k-o+{uxC07K;C+r0+VyHAQj2cR7t$ zdtCYVTkh z-v-bB>y1D7yd^P^~Y9Wgo_PUJs zM_GQ8^XFIO|K2pdZl?AQr2d@VwzrwaPaO5(<0EQsx(*b*!uey9*Z;SWy^9FHV&;?g zFBqt89)`HlCxn)o=klj(o&({s1UU*|S9@$uC^@T(B5=fQK+_`Hnb zdkoFzYbicY65hwy!+XpKUnc&?R)>#;D8Ft>_J3{k`tFSV#SP+n;#b0tPSM9WF>*v4L72lkg7Q{u#4L}vjS-i$esobc0^JC7BhZaNHv-)V ze4isQy?frx;P!Gex}Dujc=lmtJO@3CyB*)U?c-*1C*n!Ilkg4FL-@tLd$3|Z&dueX z#jj4jhBt#f;^xI~n=I~5a7(y%amT^cZYg(~TiX2|cQ;(@mUZvD!R}bMncL89?v8g` z;J(kTaS!rd?i*hcJ$HU~uHSpsU`0)q$aY^=L3wJB*_xNC2?B0^>zGS+$)qZOX=71Gxf3Uj%><-Fy zmvq;`=Ay8918iQHZH9KMy+hM`fmA=YP2&7uv@y4PHMT3nc1ai7vsh}+?_x|Po~1np zFrQb(c)uw68gla1_>O;Hw^7W6s!QTA^7>kJP4A@s z$mO?XQm(lW{;k@UYf3y{>X6@py*+X4+8@V?nd7k{kfWD!C&!$u$Dyt9+p7oT zd8LpqOM8c3Kjc5ItMzBb$eRU`F5`1a__@0jtkK?S4E%mV+TY5WgUSY;m8BguUlws>1Rvx&#r61e# zfF74wfAPJyJa9SIPC;L@WnA=rJRDZvNe-6&TiRV8`>-|Ua!fCM8Dg$|r~Myv*#0l$ zHS|@;cVlurDeI6CTT2H2H6P80-z;xk&+)h}u{jy@GQ{RGvyRhsYx{VVd^e-pDd(To zaXGAYW3d@>L3@Ab9MJg{){vz=?e?s#p>fXIHG1g#kZar9*U46h-%7Ysc5A$sU>n!K zuY%WZJ3OwnJ>HA71MX?w5%;|8F=j%y zpPLBTd19PhOyUl3^1XG?9sb5g30FPCmC6fH!bRXkapm_z5cb9XWGLZ6^Bup5UthSr z?yubhM~&-VJ#;)b-7(|2^S`X!UjM1x$M9>qeoeRRfTp{4r}5lY*oMELH2oZX^7R&Q>Ug!)~arf3M8^yn>rZdG*+9P*+kc?+gT94<7etxq z(58D2wAWBxK^cnjBFeicFQ7bw@+it9C~u+MiE;UD+JdScZbexXz5%wQOxdrp(snir@7$&)!2UkWfS;606s1V zdq+X;a6D?b7QRN_6#Hvndp62}*nb@KBcN*_#>d={odbATlx0xXNBIVFZ(%zTwnw7u zfwBwm&5)lI+qZ$g#`e$HUWDyUC|`j0KPW4qtcdb3%Bv`ULzx9~v!X1DvKY#L(C@Rt z@5iwn7yL_6PDL3T?YSEK`QY1jz)N7e7q(l1*2K7Y4BNZVH+{GS`!SK!x|=)14r!`hHv7j}5+OigFn0P7Azg&;h(H=E`8;Jy2%H{tfVF9K`n{==uu$31MRp%33HBgFi3q ztcdLw@c#$cZy*jw0z2s217#8H-vrr@QTJVx!N5b|&p%ME0zL=w$3pkvD9gdtEGQ0T zFv?%x^9Crdp`4F$G|DX~d!T%VF?dQ7%R&I?*tsi_tWT?1F(M_`Y{|^ cjz>J-h1|ZN?F`!UX>NpLUYIYBhQ34jUx&Jrc>n+a literal 0 HcmV?d00001